use PVE::QMPClient;
use PVE::RPCEnvironment;
use Time::HiRes qw(gettimeofday);
+use File::Copy qw(copy);
+
+my $qemu_snap_storage = {rbd => 1, sheepdog => 1};
my $cpuinfo = PVE::ProcFSTools::read_cpuinfo();
#no warnings 'redefine';
-unless(defined(&_VZSYSCALLS_H_)) {
- eval 'sub _VZSYSCALLS_H_ () {1;}' unless defined(&_VZSYSCALLS_H_);
- require 'sys/syscall.ph';
- if(defined(&__x86_64__)) {
- eval 'sub __NR_fairsched_vcpus () {499;}' unless defined(&__NR_fairsched_vcpus);
- eval 'sub __NR_fairsched_mknod () {504;}' unless defined(&__NR_fairsched_mknod);
- eval 'sub __NR_fairsched_rmnod () {505;}' unless defined(&__NR_fairsched_rmnod);
- eval 'sub __NR_fairsched_chwt () {506;}' unless defined(&__NR_fairsched_chwt);
- eval 'sub __NR_fairsched_mvpr () {507;}' unless defined(&__NR_fairsched_mvpr);
- eval 'sub __NR_fairsched_rate () {508;}' unless defined(&__NR_fairsched_rate);
- eval 'sub __NR_setluid () {501;}' unless defined(&__NR_setluid);
- eval 'sub __NR_setublimit () {502;}' unless defined(&__NR_setublimit);
- }
- elsif(defined( &__i386__) ) {
- eval 'sub __NR_fairsched_mknod () {500;}' unless defined(&__NR_fairsched_mknod);
- eval 'sub __NR_fairsched_rmnod () {501;}' unless defined(&__NR_fairsched_rmnod);
- eval 'sub __NR_fairsched_chwt () {502;}' unless defined(&__NR_fairsched_chwt);
- eval 'sub __NR_fairsched_mvpr () {503;}' unless defined(&__NR_fairsched_mvpr);
- eval 'sub __NR_fairsched_rate () {504;}' unless defined(&__NR_fairsched_rate);
- eval 'sub __NR_fairsched_vcpus () {505;}' unless defined(&__NR_fairsched_vcpus);
- eval 'sub __NR_setluid () {511;}' unless defined(&__NR_setluid);
- eval 'sub __NR_setublimit () {512;}' unless defined(&__NR_setublimit);
- } else {
- die("no fairsched syscall for this arch");
- }
- require 'asm/ioctl.ph';
- eval 'sub KVM_GET_API_VERSION () { &_IO(0xAE, 0x);}' unless defined(&KVM_GET_API_VERSION);
-}
-
-sub fairsched_mknod {
- my ($parent, $weight, $desired) = @_;
-
- return syscall(&__NR_fairsched_mknod, int($parent), int($weight), int($desired));
-}
-
-sub fairsched_rmnod {
- my ($id) = @_;
-
- return syscall(&__NR_fairsched_rmnod, int($id));
-}
+sub cgroups_write {
+ my ($controller, $vmid, $option, $value) = @_;
-sub fairsched_mvpr {
- my ($pid, $newid) = @_;
+ my $path = "/sys/fs/cgroup/$controller/qemu.slice/$vmid.scope/$option";
+ PVE::ProcFSTools::write_proc_entry($path, $value);
- return syscall(&__NR_fairsched_mvpr, int($pid), int($newid));
-}
-
-sub fairsched_vcpus {
- my ($id, $vcpus) = @_;
-
- return syscall(&__NR_fairsched_vcpus, int($id), int($vcpus));
-}
-
-sub fairsched_rate {
- my ($id, $op, $rate) = @_;
-
- return syscall(&__NR_fairsched_rate, int($id), int($op), int($rate));
-}
-
-use constant FAIRSCHED_SET_RATE => 0;
-use constant FAIRSCHED_DROP_RATE => 1;
-use constant FAIRSCHED_GET_RATE => 2;
-
-sub fairsched_cpulimit {
- my ($id, $limit) = @_;
-
- my $cpulim1024 = int($limit * 1024 / 100);
- my $op = $cpulim1024 ? FAIRSCHED_SET_RATE : FAIRSCHED_DROP_RATE;
-
- return fairsched_rate($id, $op, $cpulim1024);
}
my $nodename = PVE::INotify::nodename();
my $pcisysfs = "/sys/bus/pci";
+my $cpudesc = {
+ cputype => {
+ description => "Emulated CPU type.",
+ type => 'string',
+ enum => [ qw(486 athlon pentium pentium2 pentium3 coreduo core2duo kvm32 kvm64 qemu32 qemu64 phenom Conroe Penryn Nehalem Westmere SandyBridge IvyBridge Haswell Haswell-noTSX Broadwell Broadwell-noTSX Opteron_G1 Opteron_G2 Opteron_G3 Opteron_G4 Opteron_G5 host) ],
+ default => 'kvm64',
+ default_key => 1,
+ },
+ hidden => {
+ description => "Do not identify as a KVM virtual machine.",
+ type => 'boolean',
+ optional => 1,
+ default => 0
+ },
+};
+
my $confdesc = {
onboot => {
optional => 1,
},
cpulimit => {
optional => 1,
- type => 'integer',
- description => "Limit of CPU usage in per cent. Note if the computer has 2 CPUs, it has total of 200% CPU time. Value '0' indicates no CPU limit.\n\nNOTE: This option is currently ignored.",
+ type => 'number',
+ description => "Limit of CPU usage. Note if the computer has 2 CPUs, it has total of '2' CPU time. Value '0' indicates no CPU limit.",
minimum => 0,
+ maximum => 128,
default => 0,
},
cpuunits => {
pattern => '(now|\d{4}-\d{1,2}-\d{1,2}(T\d{1,2}:\d{1,2}:\d{1,2})?)',
default => 'now',
},
- startup => {
- optional => 1,
- type => 'string', format => 'pve-qm-startup',
- 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.",
- },
+ startup => get_standard_option('pve-startup-order'),
template => {
optional => 1,
type => 'boolean',
optional => 1,
description => "Emulated CPU type.",
type => 'string',
- enum => [ qw(486 athlon pentium pentium2 pentium3 coreduo core2duo kvm32 kvm64 qemu32 qemu64 phenom Conroe Penryn Nehalem Westmere SandyBridge IvyBridge Haswell Broadwell Opteron_G1 Opteron_G2 Opteron_G3 Opteron_G4 Opteron_G5 host) ],
- default => 'kvm64',
+ format => $cpudesc,
},
parent => get_standard_option('pve-snapshot-name', {
optional => 1,
machine => {
description => "Specific the Qemu machine type.",
type => 'string',
- pattern => '(pc|pc(-i440fx)?-\d+\.\d+|q35|pc-q35-\d+\.\d+)',
+ pattern => '(pc|pc(-i440fx)?-\d+\.\d+(\.pxe)?|q35|pc-q35-\d+\.\d+(\.pxe)?)',
maxLength => 40,
optional => 1,
},
smbios1 => {
description => "Specify SMBIOS type 1 fields.",
type => 'string', format => 'pve-qm-smbios1',
- typetext => "[manufacturer=str][,product=str][,version=str][,serial=str] [,uuid=uuid][,sku=str][,family=str]",
maxLength => 256,
optional => 1,
},
+ protection => {
+ optional => 1,
+ type => 'boolean',
+ description => "Sets the protection flag of the VM. This will prevent the remove operation.",
+ default => 0,
+ },
+ bios => {
+ optional => 1,
+ type => 'string',
+ enum => [ qw(seabios ovmf) ],
+ description => "Select BIOS implementation.",
+ default => 'seabios',
+ },
};
# what about other qemu settings ?
my $netdesc = {
optional => 1,
type => 'string', format => 'pve-qm-net',
- typetext => "MODEL=XX:XX:XX:XX:XX:XX [,bridge=<dev>][,queues=<nbqueues>][,rate=<mbps>] [,tag=<vlanid>][,firewall=0|1],link_down=0|1]",
+ typetext => "MODEL=XX:XX:XX:XX:XX:XX [,bridge=<dev>][,queues=<nbqueues>][,rate=<mbps>] [,tag=<vlanid>][,trunks=<vlanid[;vlanid]>][,firewall=0|1],link_down=0|1]",
description => <<EODESCR,
Specify network devices.
my $drivename_hash;
+my %drivedesc_base = (
+ volume => { alias => 'file' },
+ file => {
+ type => 'pve-volume-id',
+ default_key => 1,
+ format_description => 'volume',
+ description => "The drive's backing volume.",
+ },
+ media => {
+ type => 'string',
+ format_description => 'cdrom|disk',
+ enum => [qw(cdrom disk)],
+ description => "The drive's media type.",
+ default => 'disk',
+ optional => 1
+ },
+ cyls => {
+ type => 'integer',
+ format_description => 'count',
+ description => "Force the drive's physical geometry to have a specific cylinder count.",
+ optional => 1
+ },
+ heads => {
+ type => 'integer',
+ format_description => 'count',
+ description => "Force the drive's physical geometry to have a specific head count.",
+ optional => 1
+ },
+ secs => {
+ type => 'integer',
+ format_description => 'count',
+ description => "Force the drive's physical geometry to have a specific sector count.",
+ optional => 1
+ },
+ trans => {
+ type => 'string',
+ format_description => 'none|lba|auto',
+ enum => [qw(none lba auto)],
+ description => "Force disk geometry bios translation mode.",
+ optional => 1,
+ },
+ snapshot => {
+ type => 'boolean',
+ format_description => 'on|off',
+ description => "Whether the drive should be included when making snapshots.",
+ optional => 1,
+ },
+ cache => {
+ type => 'string',
+ format_description => 'none|writethrough|writeback|unsafe|directsync',
+ enum => [qw(none writethrough writeback unsafe directsync)],
+ description => "The drive's cache mode",
+ optional => 1,
+ },
+ format => {
+ type => 'string',
+ format_description => 'drive format',
+ enum => [qw(raw cow qcow qed qcow2 vmdk cloop)],
+ description => "The drive's backing file's data format.",
+ optional => 1,
+ },
+ size => {
+ type => 'string',
+ format => 'disk-size',
+ description => "Disk size. This is purely informational and has no effect.",
+ optional => 1,
+ },
+ backup => {
+ type => 'boolean',
+ format_description => 'on|off',
+ description => "Whether the drive should be included when making backups.",
+ optional => 1,
+ },
+ werror => {
+ type => 'string',
+ format_description => 'enospc|ignore|report|stop',
+ enum => [qw(enospc ignore report stop)],
+ description => 'Write error action.',
+ optional => 1,
+ },
+ aio => {
+ type => 'string',
+ format_description => 'native|threads',
+ enum => [qw(native threads)],
+ description => 'AIO type to use.',
+ optional => 1,
+ },
+ discard => {
+ type => 'string',
+ format_description => 'ignore|on',
+ enum => [qw(ignore on)],
+ description => 'Controls whether to pass discard/trim requests to the underlying storage.',
+ optional => 1,
+ },
+ detect_zeroes => {
+ type => 'boolean',
+ description => 'Controls whether to detect and try to optimize writes of zeroes.',
+ optional => 1,
+ },
+ serial => {
+ type => 'string',
+ format_description => 'serial',
+ description => "The drive's reported serial number.",
+ optional => 1,
+ }
+);
+
+my %rerror_fmt = (
+ rerror => {
+ type => 'string',
+ format_description => 'ignore|report|stop',
+ enum => [qw(ignore report stop)],
+ description => 'Read error action.',
+ optional => 1,
+ },
+);
+
+my %iothread_fmt = ( iothread => {
+ type => 'boolean',
+ format_description => 'off|on',
+ description => "Whether to use iothreads for this drive",
+ optional => 1,
+});
+
+my %model_fmt = (
+ model => {
+ type => 'string',
+ format_description => 'model',
+ description => "The drive's reported model name.",
+ optional => 1,
+ },
+);
+
+my %queues_fmt = (
+ queues => {
+ type => 'integer',
+ format_description => 'nbqueues',
+ description => "Number of queues.",
+ minimum => 2,
+ optional => 1
+ }
+);
+
+my $add_throttle_desc = sub {
+ my ($key, $type, $what, $size, $longsize) = @_;
+ $drivedesc_base{$key} = {
+ type => $type,
+ format_description => $size,
+ description => "Maximum $what speed in $longsize per second.",
+ optional => 1,
+ };
+};
+# throughput: (leaky bucket)
+$add_throttle_desc->('bps', 'integer', 'r/w speed', 'bps', 'bytes');
+$add_throttle_desc->('bps_rd', 'integer', 'read speed', 'bps', 'bytes');
+$add_throttle_desc->('bps_wr', 'integer', 'write speed', 'bps', 'bytes');
+$add_throttle_desc->('mbps', 'float', 'r/w speed', 'mbps', 'megabytes');
+$add_throttle_desc->('mbps_rd', 'float', 'read speed', 'mbps', 'megabytes');
+$add_throttle_desc->('mbps_wr', 'float', 'write speed', 'mbps', 'megabytes');
+$add_throttle_desc->('iops', 'integer', 'r/w I/O', 'iops', 'operations');
+$add_throttle_desc->('iops_rd', 'integer', 'read I/O', 'iops', 'operations');
+$add_throttle_desc->('iops_wr', 'integer', 'write I/O', 'iops', 'operations');
+
+# pools: (pool of IO before throttling starts taking effect)
+$add_throttle_desc->('mbps_max', 'float', 'unthrottled r/w pool', 'mbps', 'megabytes');
+$add_throttle_desc->('mbps_rd_max', 'float', 'unthrottled read pool', 'mbps', 'megabytes');
+$add_throttle_desc->('mbps_wr_max', 'float', 'unthrottled write pool', 'mbps', 'megabytes');
+$add_throttle_desc->('iops_max', 'integer', 'unthrottled r/w I/O pool', 'iops', 'operations');
+$add_throttle_desc->('iops_rd_max', 'integer', 'unthrottled read I/O pool', 'iops', 'operations');
+$add_throttle_desc->('iops_wr_max', 'integer', 'unthrottled write I/O pool', 'iops', 'operations');
+
+my $ide_fmt = {
+ %drivedesc_base,
+ %rerror_fmt,
+ %model_fmt,
+};
+
my $idedesc = {
optional => 1,
- type => 'string', format => 'pve-qm-drive',
- typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe|directsync] [,format=f] [,backup=yes|no] [,rerror=ignore|report|stop] [,werror=enospc|ignore|report|stop] [,aio=native|threads] [,discard=ignore|on]',
+ type => 'string', format => $ide_fmt,
description => "Use volume as IDE hard disk or CD-ROM (n is 0 to " .($MAX_IDE_DISKS -1) . ").",
};
PVE::JSONSchema::register_standard_option("pve-qm-ide", $idedesc);
+my $scsi_fmt = {
+ %drivedesc_base,
+ %iothread_fmt,
+ %queues_fmt,
+};
my $scsidesc = {
optional => 1,
- type => 'string', format => 'pve-qm-drive',
- typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe|directsync] [,format=f] [,backup=yes|no] [,rerror=ignore|report|stop] [,werror=enospc|ignore|report|stop] [,aio=native|threads] [,discard=ignore|on]',
+ type => 'string', format => $scsi_fmt,
description => "Use volume as SCSI hard disk or CD-ROM (n is 0 to " . ($MAX_SCSI_DISKS - 1) . ").",
};
PVE::JSONSchema::register_standard_option("pve-qm-scsi", $scsidesc);
+my $sata_fmt = {
+ %drivedesc_base,
+ %rerror_fmt,
+};
my $satadesc = {
optional => 1,
- type => 'string', format => 'pve-qm-drive',
- typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe|directsync] [,format=f] [,backup=yes|no] [,rerror=ignore|report|stop] [,werror=enospc|ignore|report|stop] [,aio=native|threads] [,discard=ignore|on]',
+ type => 'string', format => $sata_fmt,
description => "Use volume as SATA hard disk or CD-ROM (n is 0 to " . ($MAX_SATA_DISKS - 1). ").",
};
PVE::JSONSchema::register_standard_option("pve-qm-sata", $satadesc);
+my $virtio_fmt = {
+ %drivedesc_base,
+ %iothread_fmt,
+ %rerror_fmt,
+};
my $virtiodesc = {
optional => 1,
- type => 'string', format => 'pve-qm-drive',
- typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe|directsync] [,format=f] [,backup=yes|no] [,rerror=ignore|report|stop] [,werror=enospc|ignore|report|stop] [,aio=native|threads] [,discard=ignore|on] [,iothread=on]',
+ type => 'string', format => $virtio_fmt,
description => "Use volume as VIRTIO hard disk (n is 0 to " . ($MAX_VIRTIO_DISKS - 1) . ").",
};
PVE::JSONSchema::register_standard_option("pve-qm-virtio", $virtiodesc);
+my $alldrive_fmt = {
+ %drivedesc_base,
+ %rerror_fmt,
+ %iothread_fmt,
+ %model_fmt,
+ %queues_fmt,
+};
+
+my $usbformat = {
+ host => {
+ default_key => 1,
+ type => 'string', format => 'pve-qm-usb-device',
+ format_description => 'HOSTUSBDEVICE|spice',
+ description => 'The Host USB device or port or the value spice',
+ },
+ usb3 => {
+ optional => 1,
+ type => 'boolean',
+ format_description => 'yes|no',
+ description => 'Specifies whether if given host option is a USB3 device or port',
+ },
+};
+
my $usbdesc = {
optional => 1,
- type => 'string', format => 'pve-qm-usb-device',
- typetext => 'host=HOSTUSBDEVICE|spice',
+ type => 'string', format => $usbformat,
description => <<EODESCR,
Configure an USB device (n is 0 to 4). This can be used to
pass-through usb devices to the guest. HOSTUSBDEVICE syntax is:
'bus-port(.port)*' (decimal numbers) or
-'vendor_id:product_id' (hexadeciaml numbers)
+'vendor_id:product_id' (hexadeciaml numbers) or
+'spice'
You can use the 'lsusb -t' command to list existing usb devices.
The value 'spice' can be used to add a usb redirection devices for spice.
+The 'usb3' option determines whether the device is a USB3 device or not (this does currently not work reliably with spice redirection and is then ignored).
+
EODESCR
};
PVE::JSONSchema::register_standard_option("pve-qm-usb", $usbdesc);
my $hostpcidesc = {
optional => 1,
type => 'string', format => 'pve-qm-hostpci',
- typetext => "[host=]HOSTPCIDEVICE [,driver=kvm|vfio] [,rombar=on|off] [,pcie=0|1] [,x-vga=on|off]",
+ typetext => "[host=]HOSTPCIDEVICE [,rombar=on|off] [,pcie=0|1] [,x-vga=on|off]",
description => <<EODESCR,
Map host pci devices. HOSTPCIDEVICE syntax is:
description => <<EODESCR,
Create a serial device inside the VM (n is 0 to 3), and pass through a host serial device (i.e. /dev/ttyS0), or create a unix socket on the host side (use 'qm terminal' to open a terminal connection).
-Note: This option allows direct access to host hardware. So it is no longer possible to migrate such machines - use with special care.
+Note: If you pass through a host serial device, it is no longer possible to migrate such machines - use with special care.
Experimental: user reported problems with this option.
EODESCR
my $tmp = `kvm -help 2>/dev/null`;
- if ($tmp =~ m/^QEMU( PC)? emulator version (\d+\.\d+(\.\d+)?)[,\s]/) {
+ if ($tmp =~ m/^QEMU( PC)? emulator version (\d+\.\d+(\.\d+)?)(\.\d+)?[,\s]/) {
$kvm_user_version = $2;
}
my $res = {};
return $res if $data eq '0';
-
+
$data = $confdesc->{hotplug}->{default} if $data eq '1';
foreach my $feature (PVE::Tools::split_list($data)) {
die "unable to parse hotplug option\n";
}
-my $parse_size = sub {
- my ($value) = @_;
-
- return undef if $value !~ m/^(\d+(\.\d+)?)([KMG])?$/;
- my ($size, $unit) = ($1, $3);
- if ($unit) {
- if ($unit eq 'K') {
- $size = $size * 1024;
- } elsif ($unit eq 'M') {
- $size = $size * 1024 * 1024;
- } elsif ($unit eq 'G') {
- $size = $size * 1024 * 1024 * 1024;
- }
- }
- return int($size);
-};
-
-my $format_size = sub {
- my ($size) = @_;
-
- $size = int($size);
-
- my $kb = int($size/1024);
- return $size if $kb*1024 != $size;
-
- my $mb = int($kb/1024);
- return "${kb}K" if $mb*1024 != $kb;
-
- my $gb = int($mb/1024);
- return "${mb}M" if $gb*1024 != $mb;
-
- return "${gb}G";
-};
-
# ideX = [volume=]volume-id[,media=d][,cyls=c,heads=h,secs=s[,trans=t]]
# [,snapshot=on|off][,cache=on|off][,format=f][,backup=yes|no]
# [,rerror=ignore|report|stop][,werror=enospc|ignore|report|stop]
-# [,aio=native|threads][,discard=ignore|on][,iothread=on]
+# [,aio=native|threads][,discard=ignore|on][,detect_zeroes=on|off]
+# [,iothread=on][,serial=serial][,model=model]
sub parse_drive {
my ($key, $data) = @_;
- my $res = {};
+ my ($interface, $index);
- # $key may be undefined - used to verify JSON parameters
- if (!defined($key)) {
- $res->{interface} = 'unknown'; # should not harm when used to verify parameters
- $res->{index} = 0;
- } elsif ($key =~ m/^([^\d]+)(\d+)$/) {
- $res->{interface} = $1;
- $res->{index} = $2;
+ if ($key =~ m/^([^\d]+)(\d+)$/) {
+ $interface = $1;
+ $index = $2;
} else {
return undef;
}
- foreach my $p (split (/,/, $data)) {
- next if $p =~ m/^\s*$/;
-
- if ($p =~ m/^(file|volume|cyls|heads|secs|trans|media|snapshot|cache|format|rerror|werror|backup|aio|bps|mbps|mbps_max|bps_rd|mbps_rd|mbps_rd_max|bps_wr|mbps_wr|mbps_wr_max|iops|iops_max|iops_rd|iops_rd_max|iops_wr|iops_wr_max|size|discard|iothread)=(.+)$/) {
- my ($k, $v) = ($1, $2);
-
- $k = 'file' if $k eq 'volume';
-
- return undef if defined $res->{$k};
-
- if ($k eq 'bps' || $k eq 'bps_rd' || $k eq 'bps_wr') {
- return undef if !$v || $v !~ m/^\d+/;
- $k = "m$k";
- $v = sprintf("%.3f", $v / (1024*1024));
- }
- $res->{$k} = $v;
- } else {
- if (!$res->{file} && $p !~ m/=/) {
- $res->{file} = $p;
- } else {
- return undef;
+ my $desc = $key =~ /^unused\d+$/ ? $alldrive_fmt
+ : $confdesc->{$key}->{format};
+ if (!$desc) {
+ warn "invalid drive key: $key\n";
+ return undef;
+ }
+ my $res = eval { PVE::JSONSchema::parse_property_string($desc, $data) };
+ return undef if !$res;
+ $res->{interface} = $interface;
+ $res->{index} = $index;
+
+ my $error = 0;
+ foreach my $opt (qw(bps bps_rd bps_wr)) {
+ if (my $bps = defined(delete $res->{$opt})) {
+ if (defined($res->{"m$opt"})) {
+ warn "both $opt and m$opt specified\n";
+ ++$error;
+ next;
}
+ $res->{"m$opt"} = sprintf("%.3f", $bps / (1024*1024.0));
}
}
-
- return undef if !$res->{file};
-
- if($res->{file} =~ m/\.(raw|cow|qcow|qcow2|vmdk|cloop)$/){
- $res->{format} = $1;
- }
-
- return undef if $res->{cache} &&
- $res->{cache} !~ m/^(off|none|writethrough|writeback|unsafe|directsync)$/;
- return undef if $res->{snapshot} && $res->{snapshot} !~ m/^(on|off)$/;
- return undef if $res->{cyls} && $res->{cyls} !~ m/^\d+$/;
- return undef if $res->{heads} && $res->{heads} !~ m/^\d+$/;
- return undef if $res->{secs} && $res->{secs} !~ m/^\d+$/;
- return undef if $res->{media} && $res->{media} !~ m/^(disk|cdrom)$/;
- return undef if $res->{trans} && $res->{trans} !~ m/^(none|lba|auto)$/;
- return undef if $res->{format} && $res->{format} !~ m/^(raw|cow|qcow|qcow2|vmdk|cloop)$/;
- return undef if $res->{rerror} && $res->{rerror} !~ m/^(ignore|report|stop)$/;
- return undef if $res->{werror} && $res->{werror} !~ m/^(enospc|ignore|report|stop)$/;
- return undef if $res->{backup} && $res->{backup} !~ m/^(yes|no)$/;
- return undef if $res->{aio} && $res->{aio} !~ m/^(native|threads)$/;
- return undef if $res->{discard} && $res->{discard} !~ m/^(ignore|on)$/;
- return undef if $res->{iothread} && $res->{iothread} !~ m/^(on)$/;
+ return undef if $error;
return undef if $res->{mbps_rd} && $res->{mbps};
return undef if $res->{mbps_wr} && $res->{mbps};
-
- return undef if $res->{mbps} && $res->{mbps} !~ m/^\d+(\.\d+)?$/;
- return undef if $res->{mbps_max} && $res->{mbps_max} !~ m/^\d+(\.\d+)?$/;
- return undef if $res->{mbps_rd} && $res->{mbps_rd} !~ m/^\d+(\.\d+)?$/;
- return undef if $res->{mbps_rd_max} && $res->{mbps_rd_max} !~ m/^\d+(\.\d+)?$/;
- return undef if $res->{mbps_wr} && $res->{mbps_wr} !~ m/^\d+(\.\d+)?$/;
- return undef if $res->{mbps_wr_max} && $res->{mbps_wr_max} !~ m/^\d+(\.\d+)?$/;
-
return undef if $res->{iops_rd} && $res->{iops};
return undef if $res->{iops_wr} && $res->{iops};
-
- return undef if $res->{iops} && $res->{iops} !~ m/^\d+$/;
- return undef if $res->{iops_max} && $res->{iops_max} !~ m/^\d+$/;
- return undef if $res->{iops_rd} && $res->{iops_rd} !~ m/^\d+$/;
- return undef if $res->{iops_rd_max} && $res->{iops_rd_max} !~ m/^\d+$/;
- return undef if $res->{iops_wr} && $res->{iops_wr} !~ m/^\d+$/;
- return undef if $res->{iops_wr_max} && $res->{iops_wr_max} !~ m/^\d+$/;
-
-
- if ($res->{size}) {
- return undef if !defined($res->{size} = &$parse_size($res->{size}));
- }
-
if ($res->{media} && ($res->{media} eq 'cdrom')) {
return undef if $res->{snapshot} || $res->{trans} || $res->{format};
return undef if $res->{heads} || $res->{secs} || $res->{cyls};
return undef if $res->{interface} eq 'virtio';
}
- # rerror does not work with scsi drives
- if ($res->{rerror}) {
- return undef if $res->{interface} eq 'scsi';
+ if (my $size = $res->{size}) {
+ return undef if !defined($res->{size} = PVE::JSONSchema::parse_size($size));
}
return $res;
}
-my @qemu_drive_options = qw(heads secs cyls trans media format cache snapshot rerror werror aio discard iops iops_rd iops_wr iops_max iops_rd_max iops_wr_max);
-
sub print_drive {
my ($vmid, $drive) = @_;
-
- my $opts = '';
- foreach my $o (@qemu_drive_options, 'mbps', 'mbps_rd', 'mbps_wr', 'mbps_max', 'mbps_rd_max', 'mbps_wr_max', 'backup', 'iothread') {
- $opts .= ",$o=$drive->{$o}" if $drive->{$o};
- }
-
- if ($drive->{size}) {
- $opts .= ",size=" . &$format_size($drive->{size});
- }
-
- return "$drive->{file}$opts";
+ my $data = { %$drive };
+ delete $data->{$_} for qw(index interface);
+ return PVE::JSONSchema::print_property_string($data, $alldrive_fmt);
}
sub scsi_inquiry {
$device = "virtio-blk-pci,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}$pciaddr";
$device .= ",iothread=iothread-$drive->{interface}$drive->{index}" if $drive->{iothread};
} elsif ($drive->{interface} eq 'scsi') {
- if ($conf->{scsihw} && ($conf->{scsihw} =~ m/^lsi/)) {
- $maxdev = 7;
- } elsif ($conf->{scsihw} && ($conf->{scsihw} =~ m/^virtio-scsi-single/)) {
- $maxdev = 1;
- } else {
- $maxdev = 256;
- }
-
- my $controller = int($drive->{index} / $maxdev);
- my $controller_prefix = ($conf->{scsihw} && $conf->{scsihw} =~ m/^virtio-scsi-single/) ? "virtioscsi" : "scsihw";
+ my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $drive);
my $unit = $drive->{index} % $maxdev;
my $devicetype = 'hd';
my $path = '';
my $devicetype = ($drive->{media} && $drive->{media} eq 'cdrom') ? "cd" : "hd";
$device = "ide-$devicetype,bus=ide.$controller,unit=$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
+ if ($devicetype eq 'hd' && (my $model = $drive->{model})) {
+ $device .= ",model=$model";
+ }
} elsif ($drive->{interface} eq 'sata'){
my $controller = int($drive->{index} / $MAX_SATA_DISKS);
my $unit = $drive->{index} % $MAX_SATA_DISKS;
return $initiator;
}
+my @qemu_drive_options = qw(heads secs cyls trans media format cache snapshot rerror werror aio discard iops iops_rd iops_wr iops_max iops_rd_max iops_wr_max serial);
sub print_drive_full {
my ($storecfg, $vmid, $drive) = @_;
+ my $path;
+ my $volid = $drive->{file};
+ my $format;
+
+ if (drive_is_cdrom($drive)) {
+ $path = get_iso_path($storecfg, $vmid, $volid);
+ } else {
+ my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
+ if ($storeid) {
+ $path = PVE::Storage::path($storecfg, $volid);
+ my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
+ $format = qemu_img_format($scfg, $volname);
+ } else {
+ $path = $volid;
+ $format = "raw";
+ }
+ }
+
my $opts = '';
foreach my $o (@qemu_drive_options) {
next if $o eq 'bootindex';
$opts .= ",$o=$drive->{$o}" if $drive->{$o};
}
+ $opts .= ",format=$format" if $format && !$drive->{format};
+
foreach my $o (qw(bps bps_rd bps_wr)) {
my $v = $drive->{"m$o"};
$opts .= ",$o=" . int($v*1024*1024) if $v;
}
- # use linux-aio by default (qemu default is threads)
- $opts .= ",aio=native" if !$drive->{aio};
+ my $cache_direct = 0;
- my $path;
- my $volid = $drive->{file};
- if (drive_is_cdrom($drive)) {
- $path = get_iso_path($storecfg, $vmid, $volid);
- } else {
- if ($volid =~ m|^/|) {
- $path = $volid;
+ if (my $cache = $drive->{cache}) {
+ $cache_direct = $cache =~ /^(?:off|none|directsync)$/;
+ } elsif (!drive_is_cdrom($drive)) {
+ $opts .= ",cache=none";
+ $cache_direct = 1;
+ }
+
+ # aio native works only with O_DIRECT
+ if (!$drive->{aio}) {
+ if($cache_direct) {
+ $opts .= ",aio=native";
} else {
- $path = PVE::Storage::path($storecfg, $volid);
+ $opts .= ",aio=threads";
}
}
- $opts .= ",cache=none" if !$drive->{cache} && !drive_is_cdrom($drive);
-
- my $detectzeroes = $drive->{discard} ? "unmap" : "on";
- $opts .= ",detect-zeroes=$detectzeroes" if !drive_is_cdrom($drive);
+ if (!drive_is_cdrom($drive)) {
+ my $detectzeroes;
+ if (defined($drive->{detect_zeroes}) && !$drive->{detect_zeroes}) {
+ $detectzeroes = 'off';
+ } elsif ($drive->{discard}) {
+ $detectzeroes = $drive->{discard} eq 'on' ? 'unmap' : 'on';
+ } else {
+ # This used to be our default with discard not being specified:
+ $detectzeroes = 'on';
+ }
+ $opts .= ",detect-zeroes=$detectzeroes" if $detectzeroes;
+ }
my $pathinfo = $path ? "file=$path," : '';
}
sub print_netdevice_full {
- my ($vmid, $conf, $net, $netid, $bridges) = @_;
+ my ($vmid, $conf, $net, $netid, $bridges, $use_old_bios_files) = @_;
my $bootorder = $conf->{boot} || $confdesc->{boot}->{default};
$tmpstr .= ",vectors=$vectors,mq=on";
}
$tmpstr .= ",bootindex=$net->{bootindex}" if $net->{bootindex} ;
+
+ if ($use_old_bios_files) {
+ my $romfile;
+ if ($device eq 'virtio-net-pci') {
+ $romfile = 'pxe-virtio.rom';
+ } elsif ($device eq 'e1000') {
+ $romfile = 'pxe-e1000.rom';
+ } elsif ($device eq 'ne2k') {
+ $romfile = 'pxe-ne2k_pci.rom';
+ } elsif ($device eq 'pcnet') {
+ $romfile = 'pxe-pcnet.rom';
+ } elsif ($device eq 'rtl8139') {
+ $romfile = 'pxe-rtl8139.rom';
+ }
+ $tmpstr .= ",romfile=$romfile" if $romfile;
+ }
+
return $tmpstr;
}
sub print_netdev_full {
- my ($vmid, $conf, $net, $netid) = @_;
+ my ($vmid, $conf, $net, $netid, $hotplug) = @_;
my $i = '';
if ($netid =~ m/^net(\d+)$/) {
my $vmname = $conf->{name} || "vm$vmid";
my $netdev = "";
+ my $script = $hotplug ? "pve-bridge-hotplug" : "pve-bridge";
if ($net->{bridge}) {
- $netdev = "type=tap,id=$netid,ifname=${ifname},script=/var/lib/qemu-server/pve-bridge,downscript=/var/lib/qemu-server/pve-bridgedown$vhostparam";
+ $netdev = "type=tap,id=$netid,ifname=${ifname},script=/var/lib/qemu-server/$script,downscript=/var/lib/qemu-server/pve-bridgedown$vhostparam";
} else {
$netdev = "type=user,id=$netid,hostname=$vmname";
}
my $pcidevices = lspci($2);
$res->{pciid} = $pcidevices->{$2};
}
- } elsif ($kv =~ m/^driver=(kvm|vfio)$/) {
- $res->{driver} = $1;
} elsif ($kv =~ m/^rombar=(on|off)$/) {
$res->{rombar} = $1;
} elsif ($kv =~ m/^x-vga=(on|off)$/) {
$res->{rate} = $1;
} elsif ($kvp =~ m/^tag=(\d+)$/) {
$res->{tag} = $1;
+ } elsif ($kvp =~ m/^trunks=([0-9;]+)$/) {
+ $res->{trunks} = $1;
} elsif ($kvp =~ m/^firewall=([01])$/) {
$res->{firewall} = $1;
} elsif ($kvp =~ m/^link_down=([01])$/) {
$res .= ",bridge=$net->{bridge}" if $net->{bridge};
$res .= ",rate=$net->{rate}" if $net->{rate};
$res .= ",tag=$net->{tag}" if $net->{tag};
+ $res .= ",trunks=$net->{trunks}" if $net->{trunks};
$res .= ",firewall=1" if $net->{firewall};
$res .= ",link_down=1" if $net->{link_down};
$res .= ",queues=$net->{queues}" if $net->{queues};
return undef;
}
+sub split_flagged_list {
+ my $text = shift || '';
+ $text =~ s/[,;]/ /g;
+ $text =~ s/^\s+//;
+ return { map { /^(!?)(.*)$/ && ($2, $1) } ($text =~ /\S+/g) };
+}
+
+sub join_flagged_list {
+ my ($how, $lst) = @_;
+ join $how, map { $lst->{$_} . $_ } keys %$lst;
+}
+
sub vmconfig_delete_pending_option {
- my ($conf, $key) = @_;
+ my ($conf, $key, $force) = @_;
delete $conf->{pending}->{$key};
- my $pending_delete_hash = { $key => 1 };
- foreach my $opt (PVE::Tools::split_list($conf->{pending}->{delete})) {
- $pending_delete_hash->{$opt} = 1;
- }
- $conf->{pending}->{delete} = join(',', keys %$pending_delete_hash);
+ my $pending_delete_hash = split_flagged_list($conf->{pending}->{delete});
+ $pending_delete_hash->{$key} = $force ? '!' : '';
+ $conf->{pending}->{delete} = join_flagged_list(',', $pending_delete_hash);
}
sub vmconfig_undelete_pending_option {
my ($conf, $key) = @_;
- my $pending_delete_hash = {};
- foreach my $opt (PVE::Tools::split_list($conf->{pending}->{delete})) {
- $pending_delete_hash->{$opt} = 1;
- }
+ my $pending_delete_hash = split_flagged_list($conf->{pending}->{delete});
delete $pending_delete_hash->{$key};
- my @keylist = keys %$pending_delete_hash;
- if (scalar(@keylist)) {
- $conf->{pending}->{delete} = join(',', @keylist);
+ if (%$pending_delete_hash) {
+ $conf->{pending}->{delete} = join_flagged_list(',', $pending_delete_hash);
} else {
delete $conf->{pending}->{delete};
}
}
}
- # remove delete if option is not set
+ my $current_delete_hash = split_flagged_list($conf->{pending}->{delete});
my $pending_delete_hash = {};
- foreach my $opt (PVE::Tools::split_list($conf->{pending}->{delete})) {
+ while (my ($opt, $force) = each %$current_delete_hash) {
if (defined($conf->{$opt})) {
- $pending_delete_hash->{$opt} = 1;
+ $pending_delete_hash->{$opt} = $force;
} else {
$changes = 1;
}
}
- my @keylist = keys %$pending_delete_hash;
- if (scalar(@keylist)) {
- $conf->{pending}->{delete} = join(',', @keylist);
+ if (%$pending_delete_hash) {
+ $conf->{pending}->{delete} = join_flagged_list(',', $pending_delete_hash);
} else {
delete $conf->{pending}->{delete};
}
return $changes;
}
-my $valid_smbios1_options = {
- manufacturer => '\S+',
- product => '\S+',
- version => '\S+',
- serial => '\S+',
- uuid => '[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}',
- sku => '\S+',
- family => '\S+',
+# smbios: [manufacturer=str][,product=str][,version=str][,serial=str][,uuid=uuid][,sku=str][,family=str]
+my $smbios1_desc = {
+ uuid => {
+ type => 'string',
+ pattern => '[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}',
+ format_description => 'UUID',
+ optional => 1,
+ },
+ version => {
+ type => 'string',
+ pattern => '\S+',
+ format_description => 'str',
+ optional => 1,
+ },
+ serial => {
+ type => 'string',
+ pattern => '\S+',
+ format_description => 'str',
+ optional => 1,
+ },
+ manufacturer => {
+ type => 'string',
+ pattern => '\S+',
+ format_description => 'name',
+ optional => 1,
+ },
+ product => {
+ type => 'string',
+ pattern => '\S+',
+ format_description => 'name',
+ optional => 1,
+ },
+ sku => {
+ type => 'string',
+ pattern => '\S+',
+ format_description => 'str',
+ optional => 1,
+ },
+ family => {
+ type => 'string',
+ pattern => '\S+',
+ format_description => 'str',
+ optional => 1,
+ },
};
-# smbios: [manufacturer=str][,product=str][,version=str][,serial=str][,uuid=uuid][,sku=str][,family=str]
sub parse_smbios1 {
my ($data) = @_;
- my $res = {};
-
- foreach my $kvp (split(/,/, $data)) {
- return undef if $kvp !~ m/^(\S+)=(.+)$/;
- my ($k, $v) = split(/=/, $kvp);
- return undef if !defined($k) || !defined($v);
- return undef if !$valid_smbios1_options->{$k};
- return undef if $v !~ m/^$valid_smbios1_options->{$k}$/;
- $res->{$k} = $v;
- }
-
+ my $res = eval { PVE::JSONSchema::parse_property_string($smbios1_desc, $data) };
+ warn $@ if $@;
return $res;
}
sub print_smbios1 {
my ($smbios1) = @_;
-
- my $data = '';
- foreach my $k (keys %$smbios1) {
- next if !defined($smbios1->{$k});
- next if !$valid_smbios1_options->{$k};
- $data .= ',' if $data;
- $data .= "$k=$smbios1->{$k}";
- }
- return $data;
+ return PVE::JSONSchema::print_property_string($smbios1, $smbios1_desc);
}
-PVE::JSONSchema::register_format('pve-qm-smbios1', \&verify_smbios1);
-sub verify_smbios1 {
- my ($value, $noerr) = @_;
-
- return $value if parse_smbios1($value);
-
- return undef if $noerr;
-
- die "unable to parse smbios (type 1) options\n";
-}
+PVE::JSONSchema::register_format('pve-qm-smbios1', $smbios1_desc);
PVE::JSONSchema::register_format('pve-qm-bootdisk', \&verify_bootdisk);
sub verify_bootdisk {
die "unable to parse network options\n";
}
-PVE::JSONSchema::register_format('pve-qm-drive', \&verify_drive);
-sub verify_drive {
- my ($value, $noerr) = @_;
-
- return $value if parse_drive(undef, $value);
-
- return undef if $noerr;
-
- die "unable to parse drive options\n";
-}
-
PVE::JSONSchema::register_format('pve-qm-hostpci', \&verify_hostpci);
sub verify_hostpci {
my ($value, $noerr) = @_;
return $res;
}
-PVE::JSONSchema::register_format('pve-qm-startup', \&verify_startup);
-sub verify_startup {
- my ($value, $noerr) = @_;
-
- return $value if parse_startup($value);
-
- return undef if $noerr;
-
- die "unable to parse startup options\n";
-}
-
-sub parse_startup {
- my ($value) = @_;
-
- return undef if !$value;
-
- my $res = {};
-
- foreach my $p (split(/,/, $value)) {
- next if $p =~ m/^\s*$/;
-
- if ($p =~ m/^(order=)?(\d+)$/) {
- $res->{order} = $2;
- } elsif ($p =~ m/^up=(\d+)$/) {
- $res->{up} = $1;
- } elsif ($p =~ m/^down=(\d+)$/) {
- $res->{down} = $1;
- } else {
- return undef;
- }
- }
-
- return $res;
-}
-
sub parse_usb_device {
my ($value) = @_;
return undef if !$value;
- my @dl = split(/,/, $value);
- my $found;
-
my $res = {};
- foreach my $v (@dl) {
- if ($v =~ m/^host=(0x)?([0-9A-Fa-f]{4}):(0x)?([0-9A-Fa-f]{4})$/) {
- $found = 1;
- $res->{vendorid} = $2;
- $res->{productid} = $4;
- } elsif ($v =~ m/^host=(\d+)\-(\d+(\.\d+)*)$/) {
- $found = 1;
- $res->{hostbus} = $1;
- $res->{hostport} = $2;
- } elsif ($v =~ m/^spice$/) {
- $found = 1;
- $res->{spice} = 1;
- } else {
- return undef;
- }
+ if ($value =~ m/^(0x)?([0-9A-Fa-f]{4}):(0x)?([0-9A-Fa-f]{4})$/) {
+ $res->{vendorid} = $2;
+ $res->{productid} = $4;
+ } elsif ($value =~ m/^(\d+)\-(\d+(\.\d+)*)$/) {
+ $res->{hostbus} = $1;
+ $res->{hostport} = $2;
+ } elsif ($value =~ m/^spice$/i) {
+ $res->{spice} = 1;
+ } else {
+ return undef;
}
- return undef if !$found;
return $res;
}
}
sub destroy_vm {
- my ($storecfg, $vmid, $keep_empty_config) = @_;
+ my ($storecfg, $vmid, $keep_empty_config, $skiplock) = @_;
my $conffile = config_file($vmid);
my $conf = load_config($vmid);
- check_lock($conf);
+ check_lock($conf) if !$skiplock;
# only remove disks owned by this VM
foreach_drive($conf, sub {
my $vmid = $1;
my $conf = $res;
- my $descr = '';
+ my $descr;
my $section = '';
my @lines = split(/\n/, $raw);
if ($line =~ m/^\[PENDING\]\s*$/i) {
$section = 'pending';
- $conf->{description} = $descr if $descr;
- $descr = '';
+ if (defined($descr)) {
+ $descr =~ s/\s+$//;
+ $conf->{description} = $descr;
+ }
+ $descr = undef;
$conf = $res->{$section} = {};
next;
} elsif ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
$section = $1;
- $conf->{description} = $descr if $descr;
- $descr = '';
+ if (defined($descr)) {
+ $descr =~ s/\s+$//;
+ $conf->{description} = $descr;
+ }
+ $descr = undef;
$conf = $res->{snapshots}->{$section} = {};
next;
}
if ($line =~ m/^\#(.*)\s*$/) {
+ $descr = '' if !defined($descr);
$descr .= PVE::Tools::decode_text($1) . "\n";
next;
}
if ($line =~ m/^(description):\s*(.*\S)\s*$/) {
+ $descr = '' if !defined($descr);
$descr .= PVE::Tools::decode_text($2);
} elsif ($line =~ m/snapstate:\s*(prepare|delete)\s*$/) {
$conf->{snapstate} = $1;
}
}
- $conf->{description} = $descr if $descr;
-
+ if (defined($descr)) {
+ $descr =~ s/\s+$//;
+ $conf->{description} = $descr;
+ }
delete $res->{snapstate}; # just to be sure
return $res;
}
my $generate_raw_config = sub {
- my ($conf) = @_;
+ my ($conf, $pending) = @_;
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";
+ if (defined(my $descr = $conf->{description})) {
+ if ($descr) {
+ foreach my $cl (split(/\n/, $descr)) {
+ $raw .= '#' . PVE::Tools::encode_text($cl) . "\n";
+ }
+ } else {
+ $raw .= "#\n" if $pending;
+ }
}
foreach my $key (sort keys %$conf) {
if (scalar(keys %{$conf->{pending}})){
$raw .= "\n[PENDING]\n";
- $raw .= &$generate_raw_config($conf->{pending});
+ $raw .= &$generate_raw_config($conf->{pending}, 1);
}
foreach my $snapname (sort keys %{$conf->{snapshots}}) {
return $raw;
}
-sub update_config_nolock {
- my ($vmid, $conf, $skiplock) = @_;
-
- check_lock($conf) if !$skiplock;
+sub write_config {
+ my ($vmid, $conf) = @_;
my $cfspath = cfs_config_path($vmid);
PVE::Cluster::cfs_write_file($cfspath, $conf);
}
-sub update_config {
- my ($vmid, $conf, $skiplock) = @_;
-
- lock_config($vmid, &update_config_nolock, $conf, $skiplock);
-}
-
sub load_defaults {
my $res = {};
foreach my $k (keys %$conf) {
next if $k =~ m/^usb/ && ($conf->{$k} eq 'spice');
+ # sockets are safe: they will recreated be on the target side post-migrate
+ next if $k =~ m/^serial/ && ($conf->{$k} eq 'socket');
$loc_res = 1 if $k =~ m/^(usb|hostpci|serial|parallel)\d+$/;
}
$d->{netout} += $netdev->{$dev}->{receive};
$d->{netin} += $netdev->{$dev}->{transmit};
+
+ if ($full) {
+ $d->{nics}->{$dev}->{netout} = $netdev->{$dev}->{receive};
+ $d->{nics}->{$dev}->{netin} = $netdev->{$dev}->{transmit};
+ }
+
}
my $ctime = gettimeofday;
$d->{freemem} = $info->{free_mem};
}
+ $d->{ballooninfo} = $info;
};
my $blockstatscb = sub {
my $data = $resp->{'return'} || [];
my $totalrdbytes = 0;
my $totalwrbytes = 0;
+
for my $blockstat (@$data) {
$totalrdbytes = $totalrdbytes + $blockstat->{stats}->{rd_bytes};
$totalwrbytes = $totalwrbytes + $blockstat->{stats}->{wr_bytes};
+
+ $blockstat->{device} =~ s/drive-//;
+ $res->{$vmid}->{blockstat}->{$blockstat->{device}} = $blockstat->{stats};
}
$res->{$vmid}->{diskread} = $totalrdbytes;
$res->{$vmid}->{diskwrite} = $totalwrbytes;
}
}
+sub foreach_reverse_dimm {
+ my ($conf, $vmid, $memory, $sockets, $func) = @_;
+
+ my $dimm_id = 253;
+ my $current_size = 4177920;
+ my $dimm_size = 65536;
+ return if $current_size == $memory;
+
+ for (my $j = 0; $j < 8; $j++) {
+ for (my $i = 0; $i < 32; $i++) {
+ my $name = "dimm${dimm_id}";
+ $dimm_id--;
+ my $numanode = $i % $sockets;
+ $current_size -= $dimm_size;
+ &$func($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory);
+ return $current_size if $current_size <= $memory;
+ }
+ $dimm_size /= 2;
+ }
+}
+
sub foreach_drive {
my ($conf, $func) = @_;
my $q35 = machine_type_is_q35($conf);
my $hotplug_features = parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');
my $machine_type = $forcemachine || $conf->{machine};
+ my $use_old_bios_files = undef;
+ ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files($machine_type);
+
+ my $cpuunits = defined($conf->{cpuunits}) ?
+ $conf->{cpuunits} : $defaults->{cpuunits};
+
+ push @$cmd, '/usr/bin/systemd-run';
+ push @$cmd, '--scope';
+ push @$cmd, '--slice', "qemu";
+ push @$cmd, '--unit', $vmid;
+ # set KillMode=none, so that systemd don't kill those scopes
+ # at shutdown (pve-manager service should stop the VMs instead)
+ push @$cmd, '-p', "KillMode=none";
+ push @$cmd, '-p', "CPUShares=$cpuunits";
+ if ($conf->{cpulimit}) {
+ my $cpulimit = int($conf->{cpulimit} * 100);
+ push @$cmd, '-p', "CPUQuota=$cpulimit\%";
+ }
push @$cmd, '/usr/bin/kvm';
push @$cmd, '-smbios', "type=1,$conf->{smbios1}";
}
+ if ($conf->{bios} && $conf->{bios} eq 'ovmf') {
+ my $ovmfvar = "OVMF_VARS-pure-efi.fd";
+ my $ovmfvar_src = "/usr/share/kvm/$ovmfvar";
+ my $ovmfvar_dst = "/tmp/$vmid-$ovmfvar";
+ PVE::Tools::file_copy($ovmfvar_src, $ovmfvar_dst, 256*1024);
+ push @$cmd, '-drive', "if=pflash,format=raw,readonly,file=/usr/share/kvm/OVMF-pure-efi.fd";
+ push @$cmd, '-drive', "if=pflash,format=raw,file=$ovmfvar_dst";
+ }
+
if ($q35) {
# the q35 chipset support native usb2, so we enable usb controller
# by default for this machine type
my $use_usb2 = 0;
for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
next if !$conf->{"usb$i"};
+ my $d = eval { PVE::JSONSchema::parse_property_string($usbdesc->{format},$conf->{"usb$i"}) };
+ next if !$d || $d->{usb3}; # do not add usb2 controller if we have only usb3 devices
$use_usb2 = 1;
}
# include usb device config
push @$devices, '-readconfig', '/usr/share/qemu-server/pve-usb.cfg' if $use_usb2;
}
+ # add usb3 controller if needed
+
+ my $use_usb3 = 0;
+ for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
+ next if !$conf->{"usb$i"};
+ my $d = eval { PVE::JSONSchema::parse_property_string($usbdesc->{format},$conf->{"usb$i"}) };
+ next if !$d || !$d->{usb3};
+ $use_usb3 = 1;
+ }
+
+ $pciaddr = print_pci_addr("xhci", $bridges);
+ push @$devices, '-device', "nec-usb-xhci,id=xhci$pciaddr" if $use_usb3;
+
my $vga = $conf->{vga};
my $qxlnum = vga_conf_has_spice($vga);
push @$devices, '-device', print_tabletdevice_full($conf) if $tablet;
+ my $kvm_off = 0;
+ my $nohyperv;
# host pci devices
for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
my $d = parse_hostpci($conf->{"hostpci$i"});
}
my $rombar = $d->{rombar} && $d->{rombar} eq 'off' ? ",rombar=0" : "";
- my $driver = $d->{driver} && $d->{driver} eq 'vfio' ? "vfio-pci" : "pci-assign";
my $xvga = $d->{'x-vga'} && $d->{'x-vga'} eq 'on' ? ",x-vga=on" : "";
if ($xvga && $xvga ne '') {
- push @$cpuFlags, 'kvm=off';
+ $kvm_off = 1;
$vga = 'none';
+ $nohyperv = 1;
+ if ($conf->{bios} && $conf->{bios} eq 'ovmf') {
+ $xvga = "";
+ }
}
- $driver = "vfio-pci" if $xvga ne '';
my $pcidevices = $d->{pciid};
my $multifunction = 1 if @$pcidevices > 1;
$id .= ".$j" if $multifunction;
my $addr = $pciaddr;
$addr .= ".$j" if $multifunction;
- my $devicestr = "$driver,host=$pcidevice->{id}.$pcidevice->{function},id=$id$addr";
+ my $devicestr = "vfio-pci,host=$pcidevice->{id}.$pcidevice->{function},id=$id$addr";
if($j == 0){
$devicestr .= "$rombar$xvga";
# usb devices
for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
- my $d = parse_usb_device($conf->{"usb$i"});
+ next if !$conf->{"usb$i"};
+ my $d = eval { PVE::JSONSchema::parse_property_string($usbdesc->{format},$conf->{"usb$i"}) };
next if !$d;
- if ($d->{vendorid} && $d->{productid}) {
- push @$devices, '-device', "usb-host,vendorid=0x$d->{vendorid},productid=0x$d->{productid}";
- } elsif (defined($d->{hostbus}) && defined($d->{hostport})) {
- push @$devices, '-device', "usb-host,hostbus=$d->{hostbus},hostport=$d->{hostport}";
- } elsif ($d->{spice}) {
- # usb redir support for spice
- push @$devices, '-chardev', "spicevmc,id=usbredirchardev$i,name=usbredir";
- push @$devices, '-device', "usb-redir,chardev=usbredirchardev$i,id=usbredirdev$i,bus=ehci.0";
+
+ # if it is a usb3 device, attach it to the xhci controller, else omit the bus option
+ my $usbbus = '';
+ if (defined($d->{usb3}) && $d->{usb3}) {
+ $usbbus = ',bus=xhci.0';
+ }
+
+ if (defined($d->{host})) {
+ $d = parse_usb_device($d->{host});
+ if (defined($d->{vendorid}) && defined($d->{productid})) {
+ push @$devices, '-device', "usb-host$usbbus,vendorid=0x$d->{vendorid},productid=0x$d->{productid}";
+ } elsif (defined($d->{hostbus}) && defined($d->{hostport})) {
+ push @$devices, '-device', "usb-host$usbbus,hostbus=$d->{hostbus},hostport=$d->{hostport}";
+ } elsif (defined($d->{spice}) && $d->{spice}) {
+ # usb redir support for spice, currently no usb3
+ push @$devices, '-chardev', "spicevmc,id=usbredirchardev$i,name=usbredir";
+ push @$devices, '-device', "usb-redir,chardev=usbredirchardev$i,id=usbredirdev$i,bus=ehci.0";
+ }
}
}
my $allowed_vcpus = $cpuinfo->{cpus};
- die "MAX $maxcpus vcpus allowed per VM on this node\n"
+ die "MAX $allowed_vcpus vcpus allowed per VM on this node\n"
if ($allowed_vcpus < $maxcpus);
push @$cmd, '-smp', "$vcpus,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
push @$globalFlags, 'kvm-pit.lost_tick_policy=discard';
push @$cmd, '-no-hpet';
if (qemu_machine_feature_enabled ($machine_type, $kvmver, 2, 3)) {
- push @$cpuFlags , 'hv_spinlocks=0x1fff' if !$nokvm;
- push @$cpuFlags , 'hv_vapic' if !$nokvm;
- push @$cpuFlags , 'hv_time' if !$nokvm;
+ push @$cpuFlags , 'hv_spinlocks=0x1fff' if !$nokvm && !$nohyperv;
+ push @$cpuFlags , 'hv_vapic' if !$nokvm && !$nohyperv;
+ push @$cpuFlags , 'hv_time' if !$nokvm && !$nohyperv;
- } else {
- push @$cpuFlags , 'hv_spinlocks=0xffff' if !$nokvm;
+ } else {
+ push @$cpuFlags , 'hv_spinlocks=0xffff' if !$nokvm && !$nohyperv;
}
}
if ($ost eq 'win7' || $ost eq 'win8') {
- push @$cpuFlags , 'hv_relaxed' if !$nokvm;
+ push @$cpuFlags , 'hv_relaxed' if !$nokvm && !$nohyperv;
}
}
}
my $cpu = $nokvm ? "qemu64" : "kvm64";
- $cpu = $conf->{cpu} if $conf->{cpu};
+ if (my $cputype = $conf->{cpu}) {
+ my $cpuconf = PVE::JSONSchema::parse_property_string($cpudesc, $cputype)
+ or die "Cannot parse cpu description: $cputype\n";
+ $cpu = $cpuconf->{cputype};
+ $kvm_off = 1 if $cpuconf->{hidden};
+ }
push @$cpuFlags , '+lahf_lm' if $cpu eq 'kvm64';
- push @$cpuFlags , '+x2apic' if !$nokvm && $conf->{ostype} ne 'solaris';
-
- push @$cpuFlags , '-x2apic' if $conf->{ostype} eq 'solaris';
+ push @$cpuFlags , '-x2apic'
+ if $conf->{ostype} && $conf->{ostype} eq 'solaris';
push @$cpuFlags, '+sep' if $cpu eq 'kvm64' || $cpu eq 'kvm32';
+ push @$cpuFlags, '-rdtscp' if $cpu =~ m/^Opteron/;
+
if (qemu_machine_feature_enabled ($machine_type, $kvmver, 2, 3)) {
push @$cpuFlags , '+kvm_pv_unhalt' if !$nokvm;
push @$cpuFlags , '+kvm_pv_eoi' if !$nokvm;
}
+ push @$cpuFlags, 'enforce' if $cpu ne 'host' && !$nokvm;
+
+ push @$cpuFlags, 'kvm=off' if $kvm_off;
+
$cpu .= "," . join(',', @$cpuFlags) if scalar(@$cpuFlags);
- push @$cmd, '-cpu', "$cpu,enforce";
+ push @$cmd, '-cpu', $cpu;
my $memory = $conf->{memory} || $defaults->{memory};
my $static_memory = 0;
#if dimm_memory is not aligned to dimm map
if($current_size > $memory) {
$conf->{memory} = $current_size;
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
}
});
}
my $pciaddr = print_pci_addr("spice", $bridges);
- $spice_port = PVE::Tools::next_spice_port();
+ my $nodename = PVE::INotify::nodename();
+ my $pfamily = PVE::Tools::get_host_address_family($nodename);
+ $spice_port = PVE::Tools::next_spice_port($pfamily);
- push @$devices, '-spice', "tls-port=${spice_port},addr=127.0.0.1,tls-ciphers=DES-CBC3-SHA,seamless-migration=on";
+ push @$devices, '-spice', "tls-port=${spice_port},addr=localhost,tls-ciphers=DES-CBC3-SHA,seamless-migration=on";
push @$devices, '-device', "virtio-serial,id=spice$pciaddr";
push @$devices, '-chardev', "spicevmc,id=vdagent,name=vdagent";
if ($drive->{interface} eq 'scsi') {
- my $maxdev = 0;
- if ($scsihw =~ m/^lsi/) {
- $maxdev = 7;
- } elsif ($scsihw =~ m/^virtio-scsi-single/) {
- $maxdev = 1;
- } else {
- $maxdev = 256;
- }
+ my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $drive);
- my $controller = int($drive->{index} / $maxdev);
- my $controller_prefix = $scsihw =~ m/^virtio-scsi-single/ ? "virtioscsi" : "scsihw";
$pciaddr = print_pci_addr("$controller_prefix$controller", $bridges);
- my $scsihw_type = $scsihw =~ m/^virtio-scsi-single/ ? "virtio-scsi-pci" : $scsihw;
- push @$devices, '-device', "$scsihw_type,id=$controller_prefix$controller$pciaddr" if !$scsicontroller->{$controller};
+ my $scsihw_type = $scsihw =~ m/^virtio-scsi-single/ ? "virtio-scsi-pci" : $scsihw;
+
+ my $iothread = '';
+ if($conf->{scsihw} && $conf->{scsihw} eq "virtio-scsi-single" && $drive->{iothread}){
+ $iothread .= ",iothread=iothread-$controller_prefix$controller";
+ push @$cmd, '-object', "iothread,id=iothread-$controller_prefix$controller";
+ }
+
+ my $queues = '';
+ if($conf->{scsihw} && $conf->{scsihw} eq "virtio-scsi-single" && $drive->{queues}){
+ $queues = ",num_queues=$drive->{queues}";
+ }
+
+ push @$devices, '-device', "$scsihw_type,id=$controller_prefix$controller$pciaddr$iothread$queues" if !$scsicontroller->{$controller};
$scsicontroller->{$controller}=1;
}
my $netdevfull = print_netdev_full($vmid,$conf,$d,"net$i");
push @$devices, '-netdev', $netdevfull;
- my $netdevicefull = print_netdevice_full($vmid,$conf,$d,"net$i",$bridges);
+ my $netdevicefull = print_netdevice_full($vmid, $conf, $d, "net$i", $bridges, $use_old_bios_files);
push @$devices, '-device', $netdevicefull;
}
}
}
- # hack: virtio with fairsched is unreliable, so we do not use fairsched
- # when the VM uses virtio devices.
- if (!$use_virtio && $have_ovz) {
-
- my $cpuunits = defined($conf->{cpuunits}) ?
- $conf->{cpuunits} : $defaults->{cpuunits};
-
- push @$cmd, '-cpuunits', $cpuunits if $cpuunits;
-
- # fixme: cpulimit is currently ignored
- #push @$cmd, '-cpulimit', $conf->{cpulimit} if $conf->{cpulimit};
- }
-
# add custom args
if ($conf->{args}) {
my $aa = PVE::Tools::split_args($conf->{args});
die $err;
}
- } elsif ($deviceid =~ m/^(scsihw)(\d+)$/) {
+ } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
+
my $scsihw = defined($conf->{scsihw}) ? $conf->{scsihw} : "lsi";
my $pciaddr = print_pci_addr($deviceid);
- my $devicefull = "$scsihw,id=$deviceid$pciaddr";
+ my $scsihw_type = $scsihw eq 'virtio-scsi-single' ? "virtio-scsi-pci" : $scsihw;
+
+ my $devicefull = "$scsihw_type,id=$deviceid$pciaddr";
+
+ if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{iothread}) {
+ qemu_iothread_add($vmid, $deviceid, $device);
+ $devicefull .= ",iothread=iothread-$deviceid";
+ }
+
+ if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{queues}) {
+ $devicefull .= ",num_queues=$device->{queues}";
+ }
qemu_deviceadd($vmid, $devicefull);
qemu_deviceaddverify($vmid, $deviceid);
qemu_findorcreatescsihw($storecfg,$conf, $vmid, $device);
qemu_driveadd($storecfg, $vmid, $device);
-
+
my $devicefull = print_drivedevice_full($storecfg, $conf, $vmid, $device);
eval { qemu_deviceadd($vmid, $devicefull); };
if (my $err = $@) {
} elsif ($deviceid =~ m/^(net)(\d+)$/) {
return undef if !qemu_netdevadd($vmid, $conf, $device, $deviceid);
- my $netdevicefull = print_netdevice_full($vmid, $conf, $device, $deviceid);
+
+ my $machine_type = PVE::QemuServer::qemu_machine_pxe($vmid, $conf);
+ my $use_old_bios_files = undef;
+ ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files($machine_type);
+
+ my $netdevicefull = print_netdevice_full($vmid, $conf, $device, $deviceid, undef, $use_old_bios_files);
qemu_deviceadd($vmid, $netdevicefull);
eval { qemu_deviceaddverify($vmid, $deviceid); };
if (my $err = $@) {
my $bridgeid = $2;
my $pciaddr = print_pci_addr($deviceid);
my $devicefull = "pci-bridge,id=pci.$bridgeid,chassis_nr=$bridgeid$pciaddr";
-
+
qemu_deviceadd($vmid, $devicefull);
qemu_deviceaddverify($vmid, $deviceid);
} else {
- die "can't hotplug device '$deviceid'\n";
+ die "can't hotplug device '$deviceid'\n";
}
return 1;
qemu_drivedel($vmid, $deviceid);
qemu_iothread_del($conf, $vmid, $deviceid);
- } elsif ($deviceid =~ m/^(scsihw)(\d+)$/) {
-
+ } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
+
qemu_devicedel($vmid, $deviceid);
qemu_devicedelverify($vmid, $deviceid);
-
+ qemu_iothread_del($conf, $vmid, $deviceid);
+
} elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
+ #qemu 2.3 segfault on drive_del with virtioscsi + iothread
+ my $device = parse_drive($deviceid, $conf->{$deviceid});
+ die "virtioscsi with iothread is not hot-unplugglable currently" if $device->{iothread};
+
qemu_devicedel($vmid, $deviceid);
qemu_drivedel($vmid, $deviceid);
- qemu_deletescsihw($conf, $vmid, $deviceid);
+ qemu_deletescsihw($conf, $vmid, $deviceid);
} elsif ($deviceid =~ m/^(net)(\d+)$/) {
my $ret = vm_human_monitor_command($vmid, "drive_del drive-$deviceid");
$ret =~ s/^\s+//;
-
+
return 1 if $ret eq "";
-
+
# NB: device not found errors mean the drive was auto-deleted and we ignore the error
- return 1 if $ret =~ m/Device \'.*?\' not found/s;
-
+ return 1 if $ret =~ m/Device \'.*?\' not found/s;
+
die "deleting drive $deviceid failed : $ret\n";
}
sub qemu_devicedelverify {
my ($vmid, $deviceid) = @_;
- # need to verify that the device is correctly removed as device_del
+ # need to verify that the device is correctly removed as device_del
# is async and empty return is not reliable
for (my $i = 0; $i <= 5; $i++) {
sub qemu_findorcreatescsihw {
my ($storecfg, $conf, $vmid, $device) = @_;
- my $maxdev = ($conf->{scsihw} && ($conf->{scsihw} !~ m/^lsi/)) ? 256 : 7;
- my $controller = int($device->{index} / $maxdev);
- my $scsihwid="scsihw$controller";
+ my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
+
+ my $scsihwid="$controller_prefix$controller";
my $devices_list = vm_devices_list($vmid);
if(!defined($devices_list->{$scsihwid})) {
- vm_deviceplug($storecfg, $conf, $vmid, $scsihwid);
+ vm_deviceplug($storecfg, $conf, $vmid, $scsihwid, $device);
}
return 1;
my $device = parse_drive($opt, $conf->{$opt});
- my $maxdev = ($conf->{scsihw} && ($conf->{scsihw} !~ m/^lsi/)) ? 256 : 7;
- my $controller = int($device->{index} / $maxdev);
+ if ($conf->{scsihw} && ($conf->{scsihw} eq 'virtio-scsi-single')) {
+ vm_deviceunplug($vmid, $conf, "virtioscsi$device->{index}");
+ return 1;
+ }
+
+ my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
my $devices_list = vm_devices_list($vmid);
foreach my $opt (keys %{$devices_list}) {
sub qemu_set_link_status {
my ($vmid, $device, $up) = @_;
- vm_mon_cmd($vmid, "set_link", name => $device,
+ vm_mon_cmd($vmid, "set_link", name => $device,
up => $up ? JSON::true : JSON::false);
}
sub qemu_netdevadd {
my ($vmid, $conf, $device, $deviceid) = @_;
- my $netdev = print_netdev_full($vmid, $conf, $device, $deviceid);
+ my $netdev = print_netdev_full($vmid, $conf, $device, $deviceid, 1);
my %options = split(/[=,]/, $netdev);
vm_mon_cmd($vmid, "netdev_add", %options);
my ($vmid, $conf, $defaults, $opt, $value) = @_;
return $value if !check_running($vmid);
-
+
my $memory = $conf->{memory} || $defaults->{memory};
- $value = $defaults->{memory} if !$value;
+ $value = $defaults->{memory} if !$value;
return $value if $value == $memory;
my $static_memory = $STATICMEM;
my $dimm_memory = $memory - $static_memory;
die "memory can't be lower than $static_memory MB" if $value < $static_memory;
- die "memory unplug is not yet available" if $value < $memory;
die "you cannot add more memory than $MAX_MEM MB!\n" if $memory > $MAX_MEM;
my $sockets = 1;
$sockets = $conf->{sockets} if $conf->{sockets};
- foreach_dimm($conf, $vmid, $value, $sockets, sub {
- my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
+ if($value > $memory) {
- return if $current_size <= $conf->{memory};
+ foreach_dimm($conf, $vmid, $value, $sockets, sub {
+ my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
- eval { vm_mon_cmd($vmid, "object-add", 'qom-type' => "memory-backend-ram", id => "mem-$name", props => { size => int($dimm_size*1024*1024) } ) };
- if (my $err = $@) {
- eval { qemu_objectdel($vmid, "mem-$name"); };
- die $err;
- }
+ return if $current_size <= $conf->{memory};
- eval { vm_mon_cmd($vmid, "device_add", driver => "pc-dimm", id => "$name", memdev => "mem-$name", node => $numanode) };
- if (my $err = $@) {
- eval { qemu_objectdel($vmid, "mem-$name"); };
- die $err;
- }
- #update conf after each succesful module hotplug
- $conf->{memory} = $current_size;
- update_config_nolock($vmid, $conf, 1);
- });
+ eval { vm_mon_cmd($vmid, "object-add", 'qom-type' => "memory-backend-ram", id => "mem-$name", props => { size => int($dimm_size*1024*1024) } ) };
+ if (my $err = $@) {
+ eval { qemu_objectdel($vmid, "mem-$name"); };
+ die $err;
+ }
+
+ eval { vm_mon_cmd($vmid, "device_add", driver => "pc-dimm", id => "$name", memdev => "mem-$name", node => $numanode) };
+ if (my $err = $@) {
+ eval { qemu_objectdel($vmid, "mem-$name"); };
+ die $err;
+ }
+ #update conf after each succesful module hotplug
+ $conf->{memory} = $current_size;
+ write_config($vmid, $conf);
+ });
+
+ } else {
+
+ foreach_reverse_dimm($conf, $vmid, $value, $sockets, sub {
+ my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
+
+ return if $current_size >= $conf->{memory};
+ print "try to unplug memory dimm $name\n";
+
+ my $retry = 0;
+ while (1) {
+ eval { qemu_devicedel($vmid, $name) };
+ sleep 3;
+ my $dimm_list = qemu_dimm_list($vmid);
+ last if !$dimm_list->{$name};
+ raise_param_exc({ $name => "error unplug memory module" }) if $retry > 5;
+ $retry++;
+ }
+
+ #update conf after each succesful module unplug
+ $conf->{memory} = $current_size;
+
+ eval { qemu_objectdel($vmid, "mem-$name"); };
+ write_config($vmid, $conf);
+ });
+ }
+}
+
+sub qemu_dimm_list {
+ my ($vmid) = @_;
+
+ my $dimmarray = vm_mon_cmd_nocheck($vmid, "query-memory-devices");
+ my $dimms = {};
+
+ foreach my $dimm (@$dimmarray) {
+
+ $dimms->{$dimm->{data}->{id}}->{id} = $dimm->{data}->{id};
+ $dimms->{$dimm->{data}->{id}}->{node} = $dimm->{data}->{node};
+ $dimms->{$dimm->{data}->{id}}->{addr} = $dimm->{data}->{addr};
+ $dimms->{$dimm->{data}->{id}}->{size} = $dimm->{data}->{size};
+ $dimms->{$dimm->{data}->{id}}->{slot} = $dimm->{data}->{slot};
+ }
+ return $dimms;
}
sub qemu_block_set_io_throttle {
- my ($vmid, $deviceid, $bps, $bps_rd, $bps_wr, $iops, $iops_rd, $iops_wr) = @_;
+ my ($vmid, $deviceid,
+ $bps, $bps_rd, $bps_wr, $iops, $iops_rd, $iops_wr,
+ $bps_max, $bps_rd_max, $bps_wr_max, $iops_max, $iops_rd_max, $iops_wr_max) = @_;
return if !check_running($vmid) ;
- vm_mon_cmd($vmid, "block_set_io_throttle", device => $deviceid, bps => int($bps), bps_rd => int($bps_rd), bps_wr => int($bps_wr), iops => int($iops), iops_rd => int($iops_rd), iops_wr => int($iops_wr));
+ vm_mon_cmd($vmid, "block_set_io_throttle", device => $deviceid,
+ bps => int($bps),
+ bps_rd => int($bps_rd),
+ bps_wr => int($bps_wr),
+ iops => int($iops),
+ iops_rd => int($iops_rd),
+ iops_wr => int($iops_wr),
+ bps_max => int($bps_max),
+ bps_rd_max => int($bps_rd_max),
+ bps_wr_max => int($bps_wr_max),
+ iops_max => int($iops_max),
+ iops_rd_max => int($iops_rd_max),
+ iops_wr_max => int($iops_wr_max)
+ );
}
my $running = check_running($vmid);
- return if !PVE::Storage::volume_snapshot($storecfg, $volid, $snap, $running);
-
- return if !$running;
-
- vm_mon_cmd($vmid, "snapshot-drive", device => $deviceid, name => $snap);
-
+ if ($running && do_snapshots_with_qemu($storecfg, $volid)){
+ vm_mon_cmd($vmid, "snapshot-drive", device => $deviceid, name => $snap);
+ } else {
+ PVE::Storage::volume_snapshot($storecfg, $volid, $snap);
+ }
}
sub qemu_volume_snapshot_delete {
my $enabled_cap = {
"auto-converge" => 1,
- "xbzrle" => 0,
+ "xbzrle" => 1,
"x-rdma-pin-all" => 0,
"zero-blocks" => 0,
+ "compress" => 0
};
my $supported_capabilities = vm_mon_cmd_nocheck($vmid, "query-migrate-capabilities");
my $fast_plug_option = {
'lock' => 1,
'name' => 1,
- 'onboot' => 1,
+ 'onboot' => 1,
'shares' => 1,
'startup' => 1,
+ 'description' => 1,
};
# hotplug changes in [PENDING]
}
if ($changes) {
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
$conf = load_config($vmid); # update/reload
}
my $hotplug_features = parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');
- my @delete = PVE::Tools::split_list($conf->{pending}->{delete});
- foreach my $opt (@delete) {
+ my $pending_delete_hash = split_flagged_list($conf->{pending}->{delete});
+ while (my ($opt, $force) = each %$pending_delete_hash) {
next if $selection && !$selection->{$opt};
eval {
if ($opt eq 'hotplug') {
} elsif (valid_drivename($opt)) {
die "skip\n" if !$hotplug_features->{disk} || $opt =~ m/(ide|sata)(\d+)/;
vm_deviceunplug($vmid, $conf, $opt);
- vmconfig_register_unused_drive($storecfg, $vmid, $conf, parse_drive($opt, $conf->{$opt}));
+ vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
} elsif ($opt =~ m/^memory$/) {
die "skip\n" if !$hotplug_features->{memory};
qemu_memory_hotplug($vmid, $conf, $defaults, $opt);
+ } elsif ($opt eq 'cpuunits') {
+ cgroups_write("cpu", $vmid, "cpu.shares", $defaults->{cpuunits});
+ } elsif ($opt eq 'cpulimit') {
+ cgroups_write("cpu", $vmid, "cpu.cfs_quota_us", -1);
} else {
die "skip\n";
}
# save new config if hotplug was successful
delete $conf->{$opt};
vmconfig_undelete_pending_option($conf, $opt);
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
$conf = load_config($vmid); # update/reload
}
}
} elsif ($opt eq 'balloon') {
# enable/disable balloning device is not hotpluggable
my $old_balloon_enabled = !!(!defined($conf->{balloon}) || $conf->{balloon});
- my $new_balloon_enabled = !!(!defined($conf->{pending}->{balloon}) || $conf->{pending}->{balloon});
+ my $new_balloon_enabled = !!(!defined($conf->{pending}->{balloon}) || $conf->{pending}->{balloon});
die "skip\n" if $old_balloon_enabled != $new_balloon_enabled;
# allow manual ballooning if shares is set to zero
my $balloon = $conf->{pending}->{balloon} || $conf->{memory} || $defaults->{memory};
vm_mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
}
- } elsif ($opt =~ m/^net(\d+)$/) {
+ } elsif ($opt =~ m/^net(\d+)$/) {
# some changes can be done without hotplug
- vmconfig_update_net($storecfg, $conf, $hotplug_features->{network},
+ vmconfig_update_net($storecfg, $conf, $hotplug_features->{network},
$vmid, $opt, $value);
} elsif (valid_drivename($opt)) {
# some changes can be done without hotplug
} elsif ($opt =~ m/^memory$/) { #dimms
die "skip\n" if !$hotplug_features->{memory};
$value = qemu_memory_hotplug($vmid, $conf, $defaults, $opt, $value);
+ } elsif ($opt eq 'cpuunits') {
+ cgroups_write("cpu", $vmid, "cpu.shares", $conf->{pending}->{$opt});
+ } elsif ($opt eq 'cpulimit') {
+ my $cpulimit = $conf->{pending}->{$opt} == 0 ? -1 : int($conf->{pending}->{$opt} * 100000);
+ cgroups_write("cpu", $vmid, "cpu.cfs_quota_us", $cpulimit);
} else {
die "skip\n"; # skip non-hot-pluggable options
}
# save new config if hotplug was successful
$conf->{$opt} = $value;
delete $conf->{pending}->{$opt};
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
$conf = load_config($vmid); # update/reload
}
}
}
+sub try_deallocate_drive {
+ my ($storecfg, $vmid, $conf, $key, $drive, $rpcenv, $authuser, $force) = @_;
+
+ if (($force || $key =~ /^unused/) && !drive_is_cdrom($drive, 1)) {
+ my $volid = $drive->{file};
+ if (vm_is_volid_owner($storecfg, $vmid, $volid)) {
+ my $sid = PVE::Storage::parse_volume_id($volid);
+ $rpcenv->check($authuser, "/storage/$sid", ['Datastore.AllocateSpace']);
+
+ # check if the disk is really unused
+ die "unable to delete '$volid' - volume is still in use (snapshot?)\n"
+ if is_volume_in_use($storecfg, $conf, $key, $volid);
+ PVE::Storage::vdisk_free($storecfg, $volid);
+ return 1;
+ } else {
+ # If vm is not owner of this disk remove from config
+ return 1;
+ }
+ }
+
+ return undef;
+}
+
+sub vmconfig_delete_or_detach_drive {
+ my ($vmid, $storecfg, $conf, $opt, $force) = @_;
+
+ my $drive = parse_drive($opt, $conf->{$opt});
+
+ my $rpcenv = PVE::RPCEnvironment::get();
+ my $authuser = $rpcenv->get_user();
+
+ if ($force) {
+ $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
+ try_deallocate_drive($storecfg, $vmid, $conf, $opt, $drive, $rpcenv, $authuser, $force);
+ } else {
+ vmconfig_register_unused_drive($storecfg, $vmid, $conf, $drive);
+ }
+}
+
sub vmconfig_apply_pending {
my ($vmid, $conf, $storecfg) = @_;
# cold plug
- my @delete = PVE::Tools::split_list($conf->{pending}->{delete});
- foreach my $opt (@delete) { # delete
+ my $pending_delete_hash = split_flagged_list($conf->{pending}->{delete});
+ while (my ($opt, $force) = each %$pending_delete_hash) {
die "internal error" if $opt =~ m/^unused/;
$conf = load_config($vmid); # update/reload
if (!defined($conf->{$opt})) {
vmconfig_undelete_pending_option($conf, $opt);
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
} elsif (valid_drivename($opt)) {
- vmconfig_register_unused_drive($storecfg, $vmid, $conf, parse_drive($opt, $conf->{$opt}));
+ vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
vmconfig_undelete_pending_option($conf, $opt);
delete $conf->{$opt};
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
} else {
vmconfig_undelete_pending_option($conf, $opt);
delete $conf->{$opt};
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
}
}
}
delete $conf->{pending}->{$opt};
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
}
}
die "internal error" if $opt !~ m/net(\d+)/;
my $iface = "tap${vmid}i$1";
-
+
if (&$safe_num_ne($oldnet->{rate}, $newnet->{rate})) {
PVE::Network::tap_rate_limit($iface, $newnet->{rate});
}
if (&$safe_string_ne($oldnet->{bridge}, $newnet->{bridge}) ||
&$safe_num_ne($oldnet->{tag}, $newnet->{tag}) ||
+ &$safe_string_ne($oldnet->{trunks}, $newnet->{trunks}) ||
&$safe_num_ne($oldnet->{firewall}, $newnet->{firewall})) {
PVE::Network::tap_unplug($iface);
- PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall});
+ PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks});
}
if (&$safe_string_ne($oldnet->{link_down}, $newnet->{link_down})) {
return 1;
}
}
-
+
if ($hotplug) {
vm_deviceplug($storecfg, $conf, $vmid, $opt, $newnet);
} else {
if (!drive_is_cdrom($old_drive)) {
- if ($drive->{file} ne $old_drive->{file}) {
+ if ($drive->{file} ne $old_drive->{file}) {
die "skip\n" if !$hotplug;
# unplug and register as unused
vm_deviceunplug($vmid, $conf, $opt);
vmconfig_register_unused_drive($storecfg, $vmid, $conf, $old_drive)
-
+
} else {
# update existing disk
# skip non hotpluggable value
- if (&$safe_num_ne($drive->{discard}, $old_drive->{discard}) ||
+ if (&$safe_num_ne($drive->{discard}, $old_drive->{discard}) ||
&$safe_string_ne($drive->{iothread}, $old_drive->{iothread}) ||
+ &$safe_string_ne($drive->{queues}, $old_drive->{queues}) ||
&$safe_string_ne($drive->{cache}, $old_drive->{cache})) {
die "skip\n";
}
&$safe_num_ne($drive->{iops_max}, $old_drive->{iops_max}) ||
&$safe_num_ne($drive->{iops_rd_max}, $old_drive->{iops_rd_max}) ||
&$safe_num_ne($drive->{iops_wr_max}, $old_drive->{iops_wr_max})) {
-
+
qemu_block_set_io_throttle($vmid,"drive-$opt",
($drive->{mbps} || 0)*1024*1024,
($drive->{mbps_rd} || 0)*1024*1024,
$drive->{iops_wr_max} || 0);
}
-
+
return 1;
}
} else { # cdrom
-
+
if ($drive->{file} eq 'none') {
vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt");
} else {
vm_mon_cmd($vmid, "eject", force => JSON::true,device => "drive-$opt"); # force eject if locked
vm_mon_cmd($vmid, "change", device => "drive-$opt",target => "$path") if $path;
}
-
+
return 1;
}
}
}
- die "skip\n" if !$hotplug || $opt =~ m/(ide|sata)(\d+)/;
+ die "skip\n" if !$hotplug || $opt =~ m/(ide|sata)(\d+)/;
# hotplug new disks
+ PVE::Storage::activate_volumes($storecfg, [$drive->{file}]) if $drive->{file} !~ m|^/dev/.+|;
vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive);
}
sub vm_start {
- my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom, $paused, $forcemachine, $spice_ticket) = @_;
+ my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom, $paused,
+ $forcemachine, $spice_ticket) = @_;
lock_config($vmid, sub {
my $conf = load_config($vmid, $migratedfrom);
if ($statefile eq 'tcp') {
my $localip = "localhost";
my $datacenterconf = PVE::Cluster::cfs_read_file('datacenter.cfg');
+ my $nodename = PVE::INotify::nodename();
if ($datacenterconf->{migration_unsecure}) {
- my $nodename = PVE::INotify::nodename();
$localip = PVE::Cluster::remote_node_ip($nodename, 1);
+ $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
}
- $migrate_port = PVE::Tools::next_migrate_port();
+ my $pfamily = PVE::Tools::get_host_address_family($nodename);
+ $migrate_port = PVE::Tools::next_migrate_port($pfamily);
$migrate_uri = "tcp:${localip}:${migrate_port}";
push @$cmd, '-incoming', $migrate_uri;
push @$cmd, '-S';
my $info = pci_device_info("0000:$pciid");
die "IOMMU not present\n" if !check_iommu_support();
die "no pci device info for device '$pciid'\n" if !$info;
-
- if ($d->{driver} && $d->{driver} eq "vfio") {
- die "can't unbind/bind pci group to vfio '$pciid'\n" if !pci_dev_group_bind_to_vfio($pciid);
- } else {
- die "can't unbind/bind to stub pci device '$pciid'\n" if !pci_dev_bind_to_stub($info);
- }
-
+ die "can't unbind/bind pci group to vfio '$pciid'\n" if !pci_dev_group_bind_to_vfio($pciid);
die "can't reset pci device '$pciid'\n" if $info->{has_fl_reset} and !pci_dev_reset($info);
}
}
qemu_set_link_status($vmid, $opt, 0) if $nicconf->{link_down};
}
}
-
+
vm_mon_cmd_nocheck($vmid, 'qom-set',
path => "machine/peripheral/balloon0",
property => "guest-stats-polling-interval",
my ($storecfg, $vmid, $conf, $keepActive, $apply_pending_changes) = @_;
eval {
- fairsched_rmnod($vmid); # try to destroy group
if (!$keepActive) {
my $vollist = get_vm_volumes($conf);
PVE::Storage::deactivate_volumes($storecfg, $vollist);
}
-
+
foreach my $ext (qw(mon qmp pid vnc qga)) {
unlink "/var/run/qemu-server/${vmid}.$ext";
}
-
+
vmconfig_apply_pending($vmid, $conf, $storecfg) if $apply_pending_changes;
};
warn $@ if $@; # avoid errors - just warn
$conf = load_config($vmid);
check_lock($conf) if !$skiplock;
if (!defined($timeout) && $shutdown && $conf->{startup}) {
- my $opts = parse_startup($conf->{startup});
+ my $opts = PVE::JSONSchema::pve_parse_startup_order($conf->{startup});
$timeout = $opts->{down} if $opts->{down};
}
}
}
sub vm_resume {
- my ($vmid, $skiplock) = @_;
+ my ($vmid, $skiplock, $nocheck) = @_;
lock_config($vmid, sub {
- my $conf = load_config($vmid);
+ if (!$nocheck) {
- check_lock($conf) if !($skiplock || ($conf->{lock} && $conf->{lock} eq 'backup'));
+ my $conf = load_config($vmid);
+
+ check_lock($conf) if !($skiplock || ($conf->{lock} && $conf->{lock} eq 'backup'));
+
+ vm_mon_cmd($vmid, "cont");
- vm_mon_cmd($vmid, "cont");
+ } else {
+ vm_mon_cmd_nocheck($vmid, "cont");
+ }
});
}
my $conf = load_config($vmid);
- check_lock($conf) if !$skiplock;
-
if (!check_running($vmid)) {
- fairsched_rmnod($vmid); # try to destroy group
- destroy_vm($storecfg, $vmid);
+ destroy_vm($storecfg, $vmid, undef, $skiplock);
} else {
die "VM $vmid is running - destroy failed\n";
}
return file_write($fn, "1");
}
-sub pci_dev_bind_to_stub {
- my ($dev) = @_;
-
- my $name = $dev->{name};
-
- my $testdir = "$pcisysfs/drivers/pci-stub/$name";
- return 1 if -d $testdir;
-
- my $data = "$dev->{vendor} $dev->{product}";
- return undef if !file_write("$pcisysfs/drivers/pci-stub/new_id", $data);
-
- my $fn = "$pcisysfs/devices/$name/driver/unbind";
- if (!file_write($fn, $name)) {
- return undef if -f $fn;
- }
-
- $fn = "$pcisysfs/drivers/pci-stub/bind";
- if (! -d $testdir) {
- return undef if !file_write($fn, $name);
- }
-
- return -d $testdir;
-}
-
sub pci_dev_bind_to_vfio {
my ($dev) = @_;
#addr2 : first videocard
balloon0 => { bus => 0, addr => 3 },
watchdog => { bus => 0, addr => 4 },
- scsihw0 => { bus => 0, addr => 5 },
+ scsihw0 => { bus => 0, addr => 5 },
'pci.3' => { bus => 0, addr => 5 }, #can also be used for virtio-scsi-single bridge
scsihw1 => { bus => 0, addr => 6 },
ahci0 => { bus => 0, addr => 7 },
'net29' => { bus => 1, addr => 24 },
'net30' => { bus => 1, addr => 25 },
'net31' => { bus => 1, addr => 26 },
+ 'xhci' => { bus => 1, addr => 27 },
'virtio6' => { bus => 2, addr => 1 },
'virtio7' => { bus => 2, addr => 2 },
'virtio8' => { bus => 2, addr => 3 },
} elsif ($line =~ m/^((ide|scsi|virtio|sata)\d+):\s*(\S+)\s*$/) {
my $virtdev = $1;
my $value = $3;
- if ($line =~ m/backup=no/) {
+ my $di = parse_drive($virtdev, $value);
+ if (defined($di->{backup}) && !$di->{backup}) {
print $outfd "#$line";
- } elsif ($virtdev && $map->{$virtdev}) {
- my $di = parse_drive($virtdev, $value);
+ } elsif ($map->{$virtdev}) {
delete $di->{format}; # format can change on restore
$di->{file} = $map->{$virtdev};
$value = print_drive($vmid, $di);
return $volid_hash;
}
-sub get_used_paths {
- my ($vmid, $storecfg, $conf, $scan_snapshots, $skip_drive) = @_;
+sub is_volume_in_use {
+ my ($storecfg, $conf, $skip_drive, $volid) = @_;
- my $used_path = {};
+ my $path = PVE::Storage::path($storecfg, $volid);
my $scan_config = sub {
my ($cref, $snapname) = @_;
next if $skip_drive && $key eq $skip_drive;
my $drive = parse_drive($key, $value);
next if !$drive || !$drive->{file} || drive_is_cdrom($drive);
+ return 1 if $volid eq $drive->{file};
if ($drive->{file} =~ m!^/!) {
- $used_path->{$drive->{file}}++; # = 1;
+ return 1 if $drive->{file} eq $path;
} else {
my ($storeid, $volname) = PVE::Storage::parse_volume_id($drive->{file}, 1);
next if !$storeid;
my $scfg = PVE::Storage::storage_config($storecfg, $storeid, 1);
next if !$scfg;
- my $path = PVE::Storage::path($storecfg, $drive->{file}, $snapname);
- $used_path->{$path}++; # = 1;
+ return 1 if $path eq PVE::Storage::path($storecfg, $drive->{file}, $snapname);
}
}
}
+
+ return 0;
};
- &$scan_config($conf);
+ return 1 if &$scan_config($conf);
undef $skip_drive;
- if ($scan_snapshots) {
- foreach my $snapname (keys %{$conf->{snapshots}}) {
- &$scan_config($conf->{snapshots}->{$snapname}, $snapname);
- }
+ foreach my $snapname (keys %{$conf->{snapshots}}) {
+ return 1 if &$scan_config($conf->{snapshots}->{$snapname}, $snapname);
}
- return $used_path;
+ return 0;
}
sub update_disksize {
my $changes = update_disksize($vmid, $conf, $vm_volids);
- update_config_nolock($vmid, $conf, 1) if $changes;
+ write_config($vmid, $conf) if $changes;
};
if (defined($vmid)) {
my $fh = IO::File->new($cfgfn, "r") ||
"unable to read qemu-server.conf - $!\n";
+ my $fwcfgfn = "$tmpdir/qemu-server.fw";
+ if (-f $fwcfgfn) {
+ my $pve_firewall_dir = '/etc/pve/firewall';
+ mkdir $pve_firewall_dir; # make sure the dir exists
+ PVE::Tools::file_copy($fwcfgfn, "${pve_firewall_dir}/$vmid.fw");
+ }
+
while (defined(my $line = <$fh>)) {
if ($line =~ m/^\#qmdump\#map:(\S+):(\S+):(\S*):(\S*):$/) {
my ($virtdev, $devname, $storeid, $format) = ($1, $2, $3, $4);
PVE::Storage::vdisk_free($cfg, $volid);
}
});
+
+ # delete vmstate files
+ # since after the restore we have no snapshots anymore
+ foreach my $snapname (keys %{$oldconf->{snapshots}}) {
+ my $snap = $oldconf->{snapshots}->{$snapname};
+ if ($snap->{vmstate}) {
+ eval { PVE::Storage::vdisk_free($cfg, $snap->{vmstate}); };
+ if (my $err = $@) {
+ warn $err;
+ }
+ }
+ }
}
my $map = {};
$d->{volid} = $volid;
my $path = PVE::Storage::path($cfg, $volid);
+ PVE::Storage::activate_volumes($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 'glusterfs' ||
alarm($oldtimeout) if $oldtimeout;
+ my $vollist = [];
+ foreach my $devname (keys %$devinfo) {
+ my $volid = $devinfo->{$devname}->{volid};
+ push @$vollist, $volid if $volid;
+ }
+
+ my $cfg = cfs_read_file('storage.cfg');
+ PVE::Storage::deactivate_volumes($cfg, $vollist);
+
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;
return $volid;
};
+my $snapshot_save_vmstate = sub {
+ my ($vmid, $conf, $snapname, $storecfg) = @_;
+
+ my $snap = $conf->{snapshots}->{$snapname};
+
+ $snap->{vmstate} = &$alloc_vmstate_volid($storecfg, $vmid, $conf, $snapname);
+ # always overwrite machine if we save vmstate. This makes sure we
+ # can restore it later using correct machine type
+ $snap->{machine} = get_current_qemu_machine($vmid);
+};
+
my $snapshot_prepare = sub {
my ($vmid, $snapname, $save_vmstate, $comment) = @_;
if defined($conf->{snapshots}->{$snapname});
my $storecfg = PVE::Storage::config();
- die "snapshot feature is not available" if !has_feature('snapshot', $conf, $storecfg);
+ die "snapshot feature is not available\n" 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_save_vmstate($vmid, $conf, $snapname, $storecfg);
}
&$snapshot_copy_config($conf, $snap);
$snap->{snaptime} = time();
$snap->{description} = $comment if $comment;
- # always overwrite machine if we save vmstate. This makes sure we
- # can restore it later using correct machine type
- $snap->{machine} = get_current_qemu_machine($vmid) if $snap->{vmstate};
-
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
};
lock_config($vmid, $updatefn);
$newconf->{parent} = $snapname;
- update_config_nolock($vmid, $newconf, 1);
+ write_config($vmid, $newconf);
};
lock_config($vmid, $updatefn);
delete $conf->{machine} if $snap->{vmstate} && !$has_machine_config;
}
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
if (!$prepare && $snap->{vmstate}) {
my $statefile = PVE::Storage::path($storecfg, $snap->{vmstate});
}
};
+sub do_snapshots_with_qemu {
+ my ($storecfg, $volid) = @_;
+
+ my $storage_name = PVE::Storage::parse_volume_id($volid);
+
+ if ($qemu_snap_storage->{$storecfg->{ids}->{$storage_name}->{type}}
+ && !$storecfg->{ids}->{$storage_name}->{krbd}){
+ return 1;
+ }
+
+ if ($volid =~ m/\.(qcow2|qed)$/){
+ return 1;
+ }
+
+ return undef;
+}
+
+sub qga_check_running {
+ my ($vmid) = @_;
+
+ eval { vm_mon_cmd($vmid, "guest-ping", timeout => 3); };
+ if ($@) {
+ warn "Qemu Guest Agent are not running - $@";
+ return 0;
+ }
+ return 1;
+}
+
sub snapshot_create {
my ($vmid, $snapname, $save_vmstate, $comment) = @_;
my $running = check_running($vmid);
- my $freezefs = $running && $config->{agent};
+ my $freezefs = $running && $config->{agent} && qga_check_running($vmid);
$freezefs = 0 if $snap->{vmstate}; # not needed if we save RAM
my $drivehash = {};
}
}
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
};
lock_config($vmid, $updatefn);
my $voliddst = PVE::Storage::vdisk_create_base($storecfg, $volid);
$drive->{file} = $voliddst;
$conf->{$ds} = print_drive($vmid, $drive);
- update_config_nolock($vmid, $conf, 1);
+ write_config($vmid, $conf);
});
}
my ($dst_storeid, $dst_volname) = PVE::Storage::parse_volume_id($dst_volid, 1);
if ($src_storeid && $dst_storeid) {
+
+ PVE::Storage::activate_volumes($storecfg, [$src_volid], $snapname);
+
my $src_scfg = PVE::Storage::storage_config($storecfg, $src_storeid);
my $dst_scfg = PVE::Storage::storage_config($storecfg, $dst_storeid);
sub qemu_img_format {
my ($scfg, $volname) = @_;
- if ($scfg->{path} && $volname =~ m/\.(raw|qcow2|qed|vmdk)$/) {
+ if ($scfg->{path} && $volname =~ m/\.(raw|cow|qcow|qcow2|qed|vmdk|cloop)$/) {
return $1;
- } elsif ($scfg->{type} eq 'iscsi') {
- return "host_device";
} else {
return "raw";
}
sub qemu_drive_mirror {
my ($vmid, $drive, $dst_volid, $vmiddst) = @_;
- my $count = 0;
- my $old_len = 0;
- my $frozen = undef;
- my $maxwait = 120;
-
my $storecfg = PVE::Storage::config();
my ($dst_storeid, $dst_volname) = PVE::Storage::parse_volume_id($dst_volid);
my $dst_scfg = PVE::Storage::storage_config($storecfg, $dst_storeid);
- my $format;
- if ($dst_volname =~ m/\.(raw|qcow2)$/){
- $format = $1;
- }
+ my $format = qemu_img_format($dst_scfg, $dst_volname);
my $dst_path = PVE::Storage::path($storecfg, $dst_volid);
my $opts = { timeout => 10, device => "drive-$drive", mode => "existing", sync => "full", target => $dst_path };
$opts->{format} = $format if $format;
- #fixme : sometime drive-mirror timeout, but works fine after.
- # (I have see the problem with big volume > 200GB), so we need to eval
- eval { vm_mon_cmd($vmid, "drive-mirror", %$opts); };
- # ignore errors here
+ print "drive mirror is starting (scanning bitmap) : this step can take some minutes/hours, depend of disk size and storage speed\n";
eval {
+ vm_mon_cmd($vmid, "drive-mirror", %$opts);
while (1) {
my $stats = vm_mon_cmd($vmid, "query-block-jobs");
my $stat = @$stats[0];
die "error job is not mirroring" if $stat->{type} ne "mirror";
my $busy = $stat->{busy};
+ my $ready = $stat->{ready};
if (my $total = $stat->{len}) {
my $transferred = $stat->{offset} || 0;
my $remaining = $total - $transferred;
my $percent = sprintf "%.2f", ($transferred * 100 / $total);
- print "transferred: $transferred bytes remaining: $remaining bytes total: $total bytes progression: $percent % busy: $busy\n";
+ print "transferred: $transferred bytes remaining: $remaining bytes total: $total bytes progression: $percent % busy: $busy ready: $ready \n";
}
- if ($stat->{len} == $stat->{offset}) {
- if ($busy eq 'false') {
- last if $vmiddst != $vmid;
+ if ($stat->{ready} eq 'true') {
- # try to switch the disk if source and destination are on the same guest
- eval { vm_mon_cmd($vmid, "block-job-complete", device => "drive-$drive") };
- last if !$@;
- die $@ if $@ !~ m/cannot be completed/;
- }
+ last if $vmiddst != $vmid;
- if ($count > $maxwait) {
- # if too much writes to disk occurs at the end of migration
- #the disk needs to be freezed to be able to complete the migration
- vm_suspend($vmid,1);
- $frozen = 1;
- }
- $count ++
+ # try to switch the disk if source and destination are on the same guest
+ eval { vm_mon_cmd($vmid, "block-job-complete", device => "drive-$drive") };
+ last if !$@;
+ die $@ if $@ !~ m/cannot be completed/;
}
- $old_len = $stat->{offset};
sleep 1;
}
- vm_resume($vmid, 1) if $frozen;
};
my $err = $@;
my ($defFormat, $validFormats) = PVE::Storage::storage_default_format($storecfg, $storeid);
if (!$format) {
- $format = $drive->{format} || $defFormat;
+ my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
+ $format = qemu_img_format($scfg, $volname);
}
# test if requested format is supported - else use default
$newvolid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $newvmid, $format, undef, ($size/1024));
push @$newvollist, $newvolid;
+ PVE::Storage::activate_volumes($storecfg, $newvollist);
+
if (!$running || $snapname) {
qemu_img_convert($drive->{file}, $newvolid, $size, $snapname);
} else {
}
+sub qemu_machine_pxe {
+ my ($vmid, $conf, $machine) = @_;
+
+ $machine = PVE::QemuServer::get_current_qemu_machine($vmid) if !$machine;
+
+ foreach my $opt (keys %$conf) {
+ next if $opt !~ m/^net(\d+)$/;
+ my $net = PVE::QemuServer::parse_net($conf->{$opt});
+ next if !$net;
+ my $romfile = PVE::QemuServer::vm_mon_cmd_nocheck($vmid, 'qom-get', path => $opt, property => 'romfile');
+ return $machine.".pxe" if $romfile =~ m/pxe/;
+ last;
+ }
+
+}
+
+sub qemu_use_old_bios_files {
+ my ($machine_type) = @_;
+
+ return if !$machine_type;
+
+ my $use_old_bios_files = undef;
+
+ if ($machine_type =~ m/^(\S+)\.pxe$/) {
+ $machine_type = $1;
+ $use_old_bios_files = 1;
+ } else {
+ # Note: kvm version < 2.4 use non-efi pxe files, and have problems when we
+ # load new efi bios files on migration. So this hack is required to allow
+ # live migration from qemu-2.2 to qemu-2.4, which is sometimes used when
+ # updrading from proxmox-ve-3.X to proxmox-ve 4.0
+ $use_old_bios_files = !qemu_machine_feature_enabled ($machine_type, undef, 2, 4);
+ }
+
+ return ($use_old_bios_files, $machine_type);
+}
+
sub lspci {
my $devices = {};
return $iothreads;
}
+sub scsihw_infos {
+ my ($conf, $drive) = @_;
+
+ my $maxdev = 0;
+
+ if ($conf->{scsihw} && ($conf->{scsihw} =~ m/^lsi/)) {
+ $maxdev = 7;
+ } elsif ($conf->{scsihw} && ($conf->{scsihw} eq 'virtio-scsi-single')) {
+ $maxdev = 1;
+ } else {
+ $maxdev = 256;
+ }
+
+ my $controller = int($drive->{index} / $maxdev);
+ my $controller_prefix = ($conf->{scsihw} && $conf->{scsihw} eq 'virtio-scsi-single') ? "virtioscsi" : "scsihw";
+
+ return ($maxdev, $controller, $controller_prefix);
+}
+
+# bash completion helper
+
+sub complete_backup_archives {
+ my ($cmdname, $pname, $cvalue) = @_;
+
+ my $cfg = PVE::Storage::config();
+
+ my $storeid;
+
+ if ($cvalue =~ m/^([^:]+):/) {
+ $storeid = $1;
+ }
+
+ my $data = PVE::Storage::template_list($cfg, $storeid, 'backup');
+
+ my $res = [];
+ foreach my $id (keys %$data) {
+ foreach my $item (@{$data->{$id}}) {
+ next if $item->{format} !~ m/^vma\.(gz|lzo)$/;
+ push @$res, $item->{volid} if defined($item->{volid});
+ }
+ }
+
+ return $res;
+}
+
+my $complete_vmid_full = sub {
+ my ($running) = @_;
+
+ my $idlist = vmstatus();
+
+ my $res = [];
+
+ foreach my $id (keys %$idlist) {
+ my $d = $idlist->{$id};
+ if (defined($running)) {
+ next if $d->{template};
+ next if $running && $d->{status} ne 'running';
+ next if !$running && $d->{status} eq 'running';
+ }
+ push @$res, $id;
+
+ }
+ return $res;
+};
+
+sub complete_vmid {
+ return &$complete_vmid_full();
+}
+
+sub complete_vmid_stopped {
+ return &$complete_vmid_full(0);
+}
+
+sub complete_vmid_running {
+ return &$complete_vmid_full(1);
+}
+
+sub complete_storage {
+
+ my $cfg = PVE::Storage::config();
+ my $ids = $cfg->{ids};
+
+ my $res = [];
+ foreach my $sid (keys %$ids) {
+ next if !PVE::Storage::storage_check_enabled($cfg, $sid, undef, 1);
+ next if !$ids->{$sid}->{content}->{images};
+ push @$res, $sid;
+ }
+
+ return $res;
+}
+
1;