my $pcisysfs = "/sys/bus/pci";
my $confdesc = {
- iothread => {
- optional => 1,
- type => 'boolean',
- description => "Enable iothread dataplane.",
- default => 0,
- },
onboot => {
optional => 1,
type => 'boolean',
},
hotplug => {
optional => 1,
- type => 'boolean',
- description => "Allow hotplug for disk and network device",
- default => 0,
+ type => 'string', format => 'pve-hotplug-features',
+ description => "Selectively enable hotplug features. This is a comma separated list of hotplug features: 'network', 'disk', 'cpu', 'memory' and 'usb'. Use '0' to disable hotplug completely. Value '1' is an alias for the default 'network,disk,usb'.",
+ default => 'network,disk,usb',
},
reboot => {
optional => 1,
description => "Enable/disable Numa.",
default => 0,
},
- maxcpus => {
+ vcpus => {
optional => 1,
type => 'integer',
- description => "Maximum cpus for hotplug.",
+ description => "Number of hotplugged vcpus.",
minimum => 1,
- default => 1,
+ default => 0,
},
acpi => {
optional => 1,
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 Haswell Broadwell Opteron_G1 Opteron_G2 Opteron_G3 Opteron_G4 Opteron_G5 host) ],
+ 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',
},
parent => get_standard_option('pve-snapshot-name', {
my $MAX_SERIAL_PORTS = 4;
my $MAX_PARALLEL_PORTS = 3;
my $MAX_NUMA = 8;
+my $MAX_MEM = 4194304;
+my $STATICMEM = 1024;
my $numadesc = {
optional => 1,
type => 'string', format => 'pve-qm-numanode',
- typetext => "cpus=<id[-id],memory=<mb>[[,hostnodes=<id[-id]>][,policy=<preferred|bind|interleave>]]",
+ typetext => "cpus=<id[-id],memory=<mb>[[,hostnodes=<id[-id]>]
[,policy=<preferred|bind|interleave>]]",
description => "numa topology",
};
PVE::JSONSchema::register_standard_option("pve-qm-numanode", $numadesc);
}
my $nic_model_list = ['rtl8139', 'ne2k_pci', 'e1000', 'pcnet', 'virtio',
- 'ne2k_isa', 'i82551', 'i82557b', 'i82559er', 'vmxnet3'];
+ 'ne2k_isa', 'i82551', 'i82557b', 'i82559er', 'vmxnet3',
+ 'e1000-82540em', 'e1000-82544gc', 'e1000-82545em'];
my $nic_model_list_txt = join(' ', sort @$nic_model_list);
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]",
+ typetext => "MODEL=XX:XX:XX:XX:XX:XX [,bridge=<dev>][,queues=<nbqueues>][,rate=<mbps>] [,tag=<vlanid>][,firewall=0|1],link_down=0|1]",
description => <<EODESCR,
Specify network devices.
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]',
+ 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]',
description => "Use volume as VIRTIO hard disk (n is 0 to " . ($MAX_VIRTIO_DISKS - 1) . ").",
};
PVE::JSONSchema::register_standard_option("pve-qm-virtio", $virtiodesc);
PVE::Tools::file_set_contents($filename, $data);
}
+sub parse_hotplug_features {
+ my ($data) = @_;
+
+ my $res = {};
+
+ return $res if $data eq '0';
+
+ $data = $confdesc->{hotplug}->{default} if $data eq '1';
+
+ foreach my $feature (PVE::Tools::split_list($data)) {
+ if ($feature =~ m/^(network|disk|cpu|memory|usb)$/) {
+ $res->{$1} = 1;
+ } else {
+ warn "ignoring unknown hotplug feature '$feature'\n";
+ }
+ }
+ return $res;
+}
+
+PVE::JSONSchema::register_format('pve-hotplug-features', \&pve_verify_hotplug_features);
+sub pve_verify_hotplug_features {
+ my ($value, $noerr) = @_;
+
+ return $value if parse_hotplug_features($value);
+
+ return undef if $noerr;
+
+ die "unable to parse hotplug option\n";
+}
+
my $parse_size = sub {
my ($value) = @_;
# 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]
+# [,aio=native|threads][,discard=ignore|on][,iothread=on]
sub parse_drive {
my ($key, $data) = @_;
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)=(.+)$/) {
+ 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 $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 $res->{mbps_rd} && $res->{mbps};
return undef if $res->{mbps_wr} && $res->{mbps};
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') {
+ 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->{interface} eq 'virtio') {
my $pciaddr = print_pci_addr("$drive->{interface}$drive->{index}", $bridges);
$device = "virtio-blk-pci,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}$pciaddr";
- $device .= ",iothread=iothread0" if $conf->{iothread};
+ $device .= ",iothread=iothread-$drive->{interface}$drive->{index}" if $drive->{iothread};
} elsif ($drive->{interface} eq 'scsi') {
$maxdev = ($conf->{scsihw} && ($conf->{scsihw} !~ m/^lsi/)) ? 256 : 7;
my $controller = int($drive->{index} / $maxdev);
$device = 'virtio-net-pci';
};
- # qemu > 0.15 always try to boot from network - we disable that by
- # not loading the pxe rom file
- my $extra = ($bootorder !~ m/n/) ? "romfile=," : '';
my $pciaddr = print_pci_addr("$netid", $bridges);
- my $tmpstr = "$device,${extra}mac=$net->{macaddr},netdev=$netid$pciaddr,id=$netid";
+ my $tmpstr = "$device,mac=$net->{macaddr},netdev=$netid$pciaddr,id=$netid";
if ($net->{queues} && $net->{queues} > 1 && $net->{model} eq 'virtio'){
#Consider we have N queues, the number of vectors needed is 2*N + 2 (plus one config interrupt and control vq)
my $vectors = $net->{queues} * 2 + 2;
foreach my $kvp (split(/,/, $data)) {
- if ($kvp =~ m/^(ne2k_pci|e1000|rtl8139|pcnet|virtio|ne2k_isa|i82551|i82557b|i82559er|vmxnet3)(=([0-9a-f]{2}(:[0-9a-f]{2}){5}))?$/i) {
+ if ($kvp =~ m/^(ne2k_pci|e1000|e1000-82540em|e1000-82544gc|e1000-82545em|rtl8139|pcnet|virtio|ne2k_isa|i82551|i82557b|i82559er|vmxnet3)(=([0-9a-f]{2}(:[0-9a-f]{2}){5}))?$/i) {
my $model = lc($1);
my $mac = defined($3) ? uc($3) : PVE::Tools::random_ether_addr();
$res->{model} = $model;
$res->{rate} = $1;
} elsif ($kvp =~ m/^tag=(\d+)$/) {
$res->{tag} = $1;
- } elsif ($kvp =~ m/^firewall=(\d+)$/) {
+ } elsif ($kvp =~ m/^firewall=([01])$/) {
$res->{firewall} = $1;
+ } elsif ($kvp =~ m/^link_down=([01])$/) {
+ $res->{link_down} = $1;
} else {
return undef;
}
$res .= ",bridge=$net->{bridge}" if $net->{bridge};
$res .= ",rate=$net->{rate}" if $net->{rate};
$res .= ",tag=$net->{tag}" if $net->{tag};
- $res .= ",firewall=$net->{firewall}" if $net->{firewall};
+ $res .= ",firewall=1" if $net->{firewall};
+ $res .= ",link_down=1" if $net->{link_down};
+ $res .= ",queues=$net->{queues}" if $net->{queues};
return $res;
}
delete $conf->{smp};
}
- if ($conf->{maxcpus} && $conf->{sockets}) {
- delete $conf->{sockets};
- }
-
my $used_volids = {};
my $cleanup_config = sub {
$d->{cpus} = ($conf->{sockets} || 1) * ($conf->{cores} || 1);
$d->{cpus} = $cpucount if $d->{cpus} > $cpucount;
+ $d->{cpus} = $conf->{vcpus} if $conf->{vcpus};
$d->{name} = $conf->{name} || "VM $vmid";
$d->{maxmem} = $conf->{memory} ? $conf->{memory}*(1024*1024) : 0;
return $res;
}
+sub foreach_dimm {
+ my ($conf, $vmid, $memory, $sockets, $func) = @_;
+
+ my $dimm_id = 0;
+ my $current_size = 1024;
+ my $dimm_size = 512;
+ 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 $have_ovz = -f '/proc/vz/vestat';
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};
push @$cmd, '/usr/bin/kvm';
push @$cmd, '-smbios', "type=1,$conf->{smbios1}";
}
- push @$cmd, '-object', "iothread,id=iothread0" if $conf->{iothread};
-
if ($q35) {
# the q35 chipset support native usb2, so we enable usb controller
# by default for this machine type
$sockets = $conf->{sockets} if $conf->{sockets};
my $cores = $conf->{cores} || 1;
- my $maxcpus = $conf->{maxcpus} if $conf->{maxcpus};
- my $total_cores = $sockets * $cores;
- my $allowed_cores = $cpuinfo->{cpus};
+ my $maxcpus = $sockets * $cores;
- die "MAX $allowed_cores cores allowed per VM on this node\n"
- if ($allowed_cores < $total_cores);
+ my $vcpus = $conf->{vcpus} ? $conf->{vcpus} : $maxcpus;
- if ($maxcpus) {
- push @$cmd, '-smp', "cpus=$cores,maxcpus=$maxcpus";
- } else {
- push @$cmd, '-smp', "sockets=$sockets,cores=$cores";
- }
+ my $allowed_vcpus = $cpuinfo->{cpus};
+
+ die "MAX $maxcpus vcpus allowed per VM on this node\n"
+ if ($allowed_vcpus < $maxcpus);
+
+ push @$cmd, '-smp', "$vcpus,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
push @$cmd, '-nodefaults';
$i++;
}
- push @$cmd, '-boot', "menu=on";
+ push @$cmd, '-boot', "menu=on,strict=on,reboot-timeout=1000";
push @$cmd, '-no-acpi' if defined($conf->{acpi}) && $conf->{acpi} == 0;
$ost eq 'wvista') {
push @$globalFlags, 'kvm-pit.lost_tick_policy=discard';
push @$cmd, '-no-hpet';
- #push @$cpuFlags , 'hv_vapic" if !$nokvm; #fixme, my win2008R2 hang at boot with this
- push @$cpuFlags , 'hv_spinlocks=0xffff' if !$nokvm;
+ 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;
+
+ } else {
+ push @$cpuFlags , 'hv_spinlocks=0xffff' if !$nokvm;
+ }
}
if ($ost eq 'win7' || $ost eq 'win8') {
die "No accelerator found!\n" if !$cpuinfo->{hvm};
}
- my $machine_type = $forcemachine || $conf->{machine};
if ($machine_type) {
push @$machineFlags, "type=${machine_type}";
}
push @$cpuFlags, '+sep' if $cpu eq 'kvm64' || $cpu eq 'kvm32';
+ if (qemu_machine_feature_enabled ($machine_type, $kvmver, 2, 3)) {
+
+ push @$cpuFlags , '+kvm_pv_unhalt' if !$nokvm;
+ push @$cpuFlags , '+kvm_pv_eoi' if !$nokvm;
+ }
+
$cpu .= "," . join(',', @$cpuFlags) if scalar(@$cpuFlags);
- # Note: enforce needs kernel 3.10, so we do not use it for now
- # push @$cmd, '-cpu', "$cpu,enforce";
- push @$cmd, '-cpu', $cpu;
+ push @$cmd, '-cpu', "$cpu,enforce";
+
+ my $memory = $conf->{memory} || $defaults->{memory};
+ my $static_memory = 0;
+ my $dimm_memory = 0;
+
+ if ($hotplug_features->{memory}) {
+ die "Numa need to be enabled for memory hotplug\n" if !$conf->{numa};
+ die "Total memory is bigger than ${MAX_MEM}MB\n" if $memory > $MAX_MEM;
+ $static_memory = $STATICMEM;
+ die "minimum memory must be ${static_memory}MB\n" if($memory < $static_memory);
+ $dimm_memory = $memory - $static_memory;
+ push @$cmd, '-m', "size=${static_memory},slots=255,maxmem=${MAX_MEM}M";
- my $memory = $conf->{memory} || $defaults->{memory};
- push @$cmd, '-m', $memory;
+ } else {
+
+ $static_memory = $memory;
+ push @$cmd, '-m', $static_memory;
+ }
if ($conf->{numa}) {
die "missing numa node$i memory value\n" if !$numa->{memory};
my $numa_memory = $numa->{memory};
$numa_totalmemory += $numa_memory;
- my $numa_object = "memory-backend-ram,id=ram-node$i,size=$numa_memory"."M";
+ my $numa_object = "memory-backend-ram,id=ram-node$i,size=${numa_memory}M";
# cpus
my $cpus_start = $numa->{cpus}->{start};
push @$cmd, '-numa', "node,nodeid=$i,cpus=$cpus,memdev=ram-node$i";
}
- die "total memory for NUMA nodes must be equal to vm memory\n"
- if $numa_totalmemory && $numa_totalmemory != $memory;
+ die "total memory for NUMA nodes must be equal to vm static memory\n"
+ if $numa_totalmemory && $numa_totalmemory != $static_memory;
#if no custom tology, we split memory and cores across numa nodes
if(!$numa_totalmemory) {
- my $numa_memory = ($memory / $sockets) . "M";
+ my $numa_memory = ($static_memory / $sockets) . "M";
for (my $i = 0; $i < $sockets; $i++) {
}
}
+ if ($hotplug_features->{memory}) {
+ foreach_dimm($conf, $vmid, $memory, $sockets, sub {
+ my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
+ push @$cmd, "-object" , "memory-backend-ram,id=mem-$name,size=${dimm_size}M";
+ push @$cmd, "-device", "pc-dimm,id=$name,memdev=mem-$name,node=$numanode";
+
+ #if dimm_memory is not aligned to dimm map
+ if($current_size > $memory) {
+ $conf->{memory} = $current_size;
+ update_config_nolock($vmid, $conf, 1);
+ }
+ });
+ }
+
push @$cmd, '-S' if $conf->{freeze};
# set keyboard layout
}
}
+ if($drive->{interface} eq 'virtio'){
+ push @$cmd, '-object', "iothread,id=iothread-$ds" if $drive->{iothread};
+ }
+
if ($drive->{interface} eq 'scsi') {
my $maxdev = ($scsihw !~ m/^lsi/) ? 256 : 7;
if (!$q35) {
# add pci bridges
+ if (qemu_machine_feature_enabled ($machine_type, $kvmver, 2, 3)) {
+ $bridges->{1} = 1;
+ $bridges->{2} = 1;
+ }
+
while (my ($k, $v) = each %$bridges) {
$pciaddr = print_pci_addr("pci.$k");
unshift @$devices, '-device', "pci-bridge,id=pci.$k,chassis_nr=$k$pciaddr" if $k > 0;
foreach my $pcibus (@$res) {
foreach my $device (@{$pcibus->{devices}}) {
next if !$device->{'qdev_id'};
- $devices->{$device->{'qdev_id'}} = 1;
+ if ($device->{'pci_bridge'}) {
+ $devices->{$device->{'qdev_id'}} = 1;
+ foreach my $bridge_device (@{$device->{'pci_bridge'}->{devices}}) {
+ next if !$bridge_device->{'qdev_id'};
+ $devices->{$bridge_device->{'qdev_id'}} = 1;
+ $devices->{$device->{'qdev_id'}}++;
+ }
+ } else {
+ $devices->{$device->{'qdev_id'}} = 1;
+ }
}
}
sub vm_deviceplug {
my ($storecfg, $conf, $vmid, $deviceid, $device) = @_;
- die "internal error" if !$conf->{hotplug};
-
my $q35 = machine_type_is_q35($conf);
my $devices_list = vm_devices_list($vmid);
sub vm_deviceunplug {
my ($vmid, $conf, $deviceid) = @_;
- die "internal error" if !$conf->{hotplug};
-
my $devices_list = vm_devices_list($vmid);
return 1 if !defined($devices_list->{$deviceid});
qemu_devicedelverify($vmid, $deviceid);
qemu_drivedel($vmid, $deviceid);
- } elsif ($deviceid =~ m/^(lsi)(\d+)$/) {
+ } elsif ($deviceid =~ m/^(scsihw)(\d+)$/) {
qemu_devicedel($vmid, $deviceid);
+ qemu_devicedelverify($vmid, $deviceid);
} elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
qemu_devicedel($vmid, $deviceid);
qemu_drivedel($vmid, $deviceid);
-
+ qemu_deletescsihw($conf, $vmid, $deviceid);
+
} elsif ($deviceid =~ m/^(net)(\d+)$/) {
qemu_devicedel($vmid, $deviceid);
my $ret = vm_mon_cmd($vmid, "device_del", id => $deviceid);
}
+sub qemu_objectadd {
+ my($vmid, $objectid, $qomtype) = @_;
+
+ vm_mon_cmd($vmid, "object-add", id => $objectid, "qom-type" => $qomtype);
+
+ return 1;
+}
+
+sub qemu_objectdel {
+ my($vmid, $objectid) = @_;
+
+ vm_mon_cmd($vmid, "object-del", id => $objectid);
+
+ return 1;
+}
+
sub qemu_driveadd {
my ($storecfg, $vmid, $device) = @_;
my $drive = print_drive_full($storecfg, $vmid, $device);
- my $ret = vm_human_monitor_command($vmid, "drive_add auto $drive");
+ $drive =~ s/\\/\\\\/g;
+ my $ret = vm_human_monitor_command($vmid, "drive_add auto \"$drive\"");
# If the command succeeds qemu prints: "OK"
return 1 if $ret =~ m/OK/s;
return 1;
}
+sub qemu_deletescsihw {
+ my ($conf, $vmid, $opt) = @_;
+
+ my $device = parse_drive($opt, $conf->{$opt});
+
+ my $maxdev = ($conf->{scsihw} && ($conf->{scsihw} !~ m/^lsi/)) ? 256 : 7;
+ my $controller = int($device->{index} / $maxdev);
+
+ my $devices_list = vm_devices_list($vmid);
+ foreach my $opt (keys %{$devices_list}) {
+ if (PVE::QemuServer::valid_drivename($opt)) {
+ my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
+ if($drive->{interface} eq 'scsi' && $drive->{index} < (($maxdev-1)*($controller+1))) {
+ return 1;
+ }
+ }
+ }
+
+ my $scsihwid="scsihw$controller";
+
+ vm_deviceunplug($vmid, $conf, $scsihwid);
+
+ return 1;
+}
+
sub qemu_add_pci_bridge {
my ($storecfg, $conf, $vmid, $device) = @_;
return 1;
}
+sub qemu_set_link_status {
+ my ($vmid, $device, $up) = @_;
+
+ vm_mon_cmd($vmid, "set_link", name => $device,
+ up => $up ? JSON::true : JSON::false);
+}
+
sub qemu_netdevadd {
my ($vmid, $conf, $device, $deviceid) = @_;
}
sub qemu_cpu_hotplug {
- my ($vmid, $conf, $cores) = @_;
+ my ($vmid, $conf, $vcpus) = @_;
- my $sockets = $conf->{sockets} || 1;
- die "cpu hotplug only works with one socket\n"
- if $sockets > 1;
+ my $sockets = 1;
+ $sockets = $conf->{smp} if $conf->{smp}; # old style - no longer iused
+ $sockets = $conf->{sockets} if $conf->{sockets};
+ my $cores = $conf->{cores} || 1;
+ my $maxcpus = $sockets * $cores;
- die "maxcpus is not defined\n"
- if !$conf->{maxcpus};
+ $vcpus = $maxcpus if !$vcpus;
- die "you can't add more cores than maxcpus\n"
- if $cores > $conf->{maxcpus};
+ die "you can't add more vcpus than maxcpus\n"
+ if $vcpus > $maxcpus;
- my $currentcores = $conf->{cores} || 1;
+ my $currentvcpus = $conf->{vcpus} || $maxcpus;
die "online cpu unplug is not yet possible\n"
- if $cores < $currentcores;
+ if $vcpus < $currentvcpus;
- my $currentrunningcores = vm_mon_cmd($vmid, "query-cpus");
- die "cores number if running vm is different than configuration\n"
- if scalar(@{$currentrunningcores}) != $currentcores;
+ my $currentrunningvcpus = vm_mon_cmd($vmid, "query-cpus");
+ die "vcpus in running vm is different than configuration\n"
+ if scalar(@{$currentrunningvcpus}) != $currentvcpus;
- for (my $i = $currentcores; $i < $cores; $i++) {
+ for (my $i = $currentvcpus; $i < $vcpus; $i++) {
vm_mon_cmd($vmid, "cpu-add", id => int($i));
}
}
+sub qemu_memory_hotplug {
+ my ($vmid, $conf, $defaults, $opt, $value) = @_;
+
+ return $value if !check_running($vmid);
+
+ my $memory = $conf->{memory} || $defaults->{memory};
+ $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) = @_;
+
+ return if $current_size <= $conf->{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;
+ }
+
+ 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);
+ });
+}
+
sub qemu_block_set_io_throttle {
my ($vmid, $deviceid, $bps, $bps_rd, $bps_wr, $iops, $iops_rd, $iops_wr) = @_;
vm_mon_cmd_nocheck($vmid, "migrate-set-capabilities", capabilities => $cap_ref);
}
+my $fast_plug_option = {
+ 'lock' => 1,
+ 'name' => 1,
+ 'onboot' => 1,
+ 'shares' => 1,
+ 'startup' => 1,
+};
+
# hotplug changes in [PENDING]
# $selection hash can be used to only apply specified options, for
# example: { cores => 1 } (only apply changed 'cores')
my $changes = 0;
foreach my $opt (keys %{$conf->{pending}}) { # add/change
- if ($opt eq 'name' || $opt eq 'hotplug' || $opt eq 'onboot' || $opt eq 'shares') {
+ if ($fast_plug_option->{$opt}) {
$conf->{$opt} = $conf->{pending}->{$opt};
delete $conf->{pending}->{$opt};
$changes = 1;
$conf = load_config($vmid); # update/reload
}
- my $hotplug = defined($conf->{hotplug}) ? $conf->{hotplug} : $defaults->{hotplug};
+ 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) {
next if $selection && !$selection->{$opt};
eval {
- if ($opt eq 'tablet') {
- die "skip\n" if !$hotplug;
+ if ($opt eq 'hotplug') {
+ die "skip\n" if ($conf->{hotplug} =~ /memory/);
+ } elsif ($opt eq 'tablet') {
+ die "skip\n" if !$hotplug_features->{usb};
if ($defaults->{tablet}) {
vm_deviceplug($storecfg, $conf, $vmid, $opt);
} else {
vm_deviceunplug($vmid, $conf, $opt);
}
- } elsif ($opt eq 'cores') {
- die "skip\n" if !$hotplug;
- qemu_cpu_hotplug($vmid, $conf, 1);
+ } elsif ($opt eq 'vcpus') {
+ die "skip\n" if !$hotplug_features->{cpu};
+ qemu_cpu_hotplug($vmid, $conf, undef);
+ } elsif ($opt eq 'balloon') {
+ # enable balloon device is not hotpluggable
+ die "skip\n" if !defined($conf->{balloon}) || $conf->{balloon};
+ } elsif ($fast_plug_option->{$opt}) {
+ # do nothing
} elsif ($opt =~ m/^net(\d+)$/) {
- die "skip\n" if !$hotplug;
+ die "skip\n" if !$hotplug_features->{network};
vm_deviceunplug($vmid, $conf, $opt);
} elsif (valid_drivename($opt)) {
- die "skip\n" if !$hotplug || $opt =~ m/(ide|sata)(\d+)/;
+ 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}));
+ } elsif ($opt =~ m/^memory$/) {
+ die "skip\n" if !$hotplug_features->{memory};
+ qemu_memory_hotplug($vmid, $conf, $defaults, $opt);
} else {
die "skip\n";
}
next if $selection && !$selection->{$opt};
my $value = $conf->{pending}->{$opt};
eval {
- if ($opt eq 'tablet') {
- die "skip\n" if !$hotplug;
+ if ($opt eq 'hotplug') {
+ die "skip\n" if ($value =~ /memory/) || ($value !~ /memory/ && $conf->{hotplug} =~ /memory/);
+ } elsif ($opt eq 'tablet') {
+ die "skip\n" if !$hotplug_features->{usb};
if ($value == 1) {
vm_deviceplug($storecfg, $conf, $vmid, $opt);
} elsif ($value == 0) {
vm_deviceunplug($vmid, $conf, $opt);
}
- } elsif ($opt eq 'cores') {
- die "skip\n" if !$hotplug;
+ } elsif ($opt eq 'vcpus') {
+ die "skip\n" if !$hotplug_features->{cpu};
qemu_cpu_hotplug($vmid, $conf, $value);
} elsif ($opt eq 'balloon') {
- die "skip\n" if !(defined($conf->{shares}) && ($conf->{shares} == 0));
+ # 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});
+ 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);
+ if ((defined($conf->{shares}) && ($conf->{shares} == 0))) {
+ my $balloon = $conf->{pending}->{balloon} || $conf->{memory} || $defaults->{memory};
+ vm_mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
+ }
} elsif ($opt =~ m/^net(\d+)$/) {
# some changes can be done without hotplug
- vmconfig_update_net($storecfg, $conf, $vmid, $opt, $value);
+ vmconfig_update_net($storecfg, $conf, $hotplug_features->{network},
+ $vmid, $opt, $value);
} elsif (valid_drivename($opt)) {
# some changes can be done without hotplug
- vmconfig_update_disk($storecfg, $conf, $vmid, $opt, $value, 1);
+ vmconfig_update_disk($storecfg, $conf, $hotplug_features->{disk},
+ $vmid, $opt, $value, 1);
+ } elsif ($opt =~ m/^memory$/) { #dimms
+ die "skip\n" if !$hotplug_features->{memory};
+ $value = qemu_memory_hotplug($vmid, $conf, $defaults, $opt, $value);
} else {
die "skip\n"; # skip non-hot-pluggable options
}
};
sub vmconfig_update_net {
- my ($storecfg, $conf, $vmid, $opt, $value) = @_;
+ my ($storecfg, $conf, $hotplug, $vmid, $opt, $value) = @_;
my $newnet = parse_net($value);
!($newnet->{bridge} && $oldnet->{bridge})) { # bridge/nat mode change
# for non online change, we try to hot-unplug
- die "skip\n" if !$conf->{hotplug};
+ die "skip\n" if !$hotplug;
vm_deviceunplug($vmid, $conf, $opt);
} else {
PVE::Network::tap_rate_limit($iface, $newnet->{rate});
}
- if(&$safe_string_ne($oldnet->{bridge}, $newnet->{bridge}) ||
- &$safe_num_ne($oldnet->{tag}, $newnet->{tag}) ||
- &$safe_num_ne($oldnet->{firewall}, $newnet->{firewall})) {
+ if (&$safe_string_ne($oldnet->{bridge}, $newnet->{bridge}) ||
+ &$safe_num_ne($oldnet->{tag}, $newnet->{tag}) ||
+ &$safe_num_ne($oldnet->{firewall}, $newnet->{firewall})) {
PVE::Network::tap_unplug($iface);
PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall});
}
+ if (&$safe_string_ne($oldnet->{link_down}, $newnet->{link_down})) {
+ qemu_set_link_status($vmid, $opt, !$newnet->{link_down});
+ }
+
return 1;
}
}
- if ($conf->{hotplug}) {
+ if ($hotplug) {
vm_deviceplug($storecfg, $conf, $vmid, $opt, $newnet);
} else {
die "skip\n";
}
sub vmconfig_update_disk {
- my ($storecfg, $conf, $vmid, $opt, $value, $force) = @_;
+ my ($storecfg, $conf, $hotplug, $vmid, $opt, $value, $force) = @_;
# fixme: do we need force?
if ($drive->{file} ne $old_drive->{file}) {
- die "skip\n" if !$conf->{hotplug};
+ die "skip\n" if !$hotplug;
# unplug and register as unused
vm_deviceunplug($vmid, $conf, $opt);
return 1;
}
+
+ } else { # cdrom
+
+ if ($drive->{file} eq 'none') {
+ vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt");
+ } else {
+ my $path = get_iso_path($storecfg, $vmid, $drive->{file});
+ 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;
}
}
}
- if (drive_is_cdrom($drive)) { # cdrom
-
- if ($drive->{file} eq 'none') {
- vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt");
- } else {
- my $path = get_iso_path($storecfg, $vmid, $drive->{file});
- 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;
- }
-
- } else {
- die "skip\n" if !$conf->{hotplug} || $opt =~ m/(ide|sata)(\d+)/;
- # hotplug new disks
- vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive);
- }
+ die "skip\n" if !$hotplug || $opt =~ m/(ide|sata)(\d+)/;
+ # hotplug new disks
+ vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive);
}
sub vm_start {
if (!$statefile && (!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);
+ }
+
+ foreach my $opt (keys %$conf) {
+ next if $opt !~ m/^net\d+$/;
+ my $nicconf = parse_net($conf->{$opt});
+ 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",
+ value => 2) if (!defined($conf->{balloon}) || $conf->{balloon});
+
});
}
}
sub vm_stop_cleanup {
- my ($storecfg, $vmid, $conf, $keepActive) = @_;
+ my ($storecfg, $vmid, $conf, $keepActive, $apply_pending_changes) = @_;
eval {
fairsched_rmnod($vmid); # try to destroy group
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
}
my $pid = check_running($vmid, $nocheck, $migratedfrom);
kill 15, $pid if $pid;
my $conf = load_config($vmid, $migratedfrom);
- vm_stop_cleanup($storecfg, $vmid, $conf, $keepActive);
+ vm_stop_cleanup($storecfg, $vmid, $conf, $keepActive, 0);
return;
}
eval {
if ($shutdown) {
- if (!$nocheck && $conf->{agent}) {
+ if (defined($conf) && $conf->{agent}) {
vm_qmp_command($vmid, { execute => "guest-shutdown" }, $nocheck);
} else {
vm_qmp_command($vmid, { execute => "system_powerdown" }, $nocheck);
die "VM quit/powerdown failed - got timeout\n";
}
} else {
- vm_stop_cleanup($storecfg, $vmid, $conf, $keepActive) if $conf;
+ vm_stop_cleanup($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
return;
}
} else {
sleep 1;
}
- vm_stop_cleanup($storecfg, $vmid, $conf, $keepActive) if $conf;
+ vm_stop_cleanup($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
});
}
foreach my $pciid (@devs) {
$pciid =~ m/^([:\.\da-f]+)$/ or die "PCI ID $pciid not valid!\n";
+
+ # pci bridges, switches or root ports are not supported
+ # they have a pci_bus subdirectory so skip them
+ next if (-e "$pcisysfs/devices/$pciid/pci_bus");
+
my $info = pci_device_info($1);
pci_dev_bind_to_vfio($info) || die "Cannot bind $pciid to vfio\n";
}
sub snapshot_rollback {
my ($vmid, $snapname) = @_;
- my $snap;
-
my $prepare = 1;
my $storecfg = PVE::Storage::config();
- my $updatefn = sub {
+ my $conf = load_config($vmid);
- my $conf = load_config($vmid);
+ my $get_snapshot_config = sub {
die "you can't rollback if vm is a template\n" if is_template($conf);
- $snap = $conf->{snapshots}->{$snapname};
+ my $res = $conf->{snapshots}->{$snapname};
- die "snapshot '$snapname' does not exist\n" if !defined($snap);
+ die "snapshot '$snapname' does not exist\n" if !defined($res);
+
+ return $res;
+ };
+
+ my $snap = &$get_snapshot_config();
+
+ foreach_drive($snap, sub {
+ my ($ds, $drive) = @_;
+
+ return if drive_is_cdrom($drive);
+
+ my $volid = $drive->{file};
+
+ PVE::Storage::volume_rollback_is_possible($storecfg, $volid, $snapname);
+ });
+
+ my $updatefn = sub {
+
+ $conf = load_config($vmid);
+
+ $snap = &$get_snapshot_config();
die "unable to rollback to incomplete snapshot (snapstate = $snap->{snapstate})\n"
if $snap->{snapstate};
return $current || $default || 'pc';
}
+sub qemu_machine_feature_enabled {
+ my ($machine, $kvmver, $version_major, $version_minor) = @_;
+
+ my $current_major;
+ my $current_minor;
+
+ if ($machine && $machine =~ m/^(pc(-i440fx|-q35)?-(\d+)\.(\d+))/) {
+
+ $current_major = $3;
+ $current_minor = $4;
+
+ } elsif ($kvmver =~ m/^(\d+)\.(\d+)/) {
+
+ $current_major = $1;
+ $current_minor = $2;
+ }
+
+ return 1 if $current_major >= $version_major && $current_minor >= $version_minor;
+
+
+}
+
sub lspci {
my $devices = {};
projects / qemu-server.git / blobdiff